﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace V82.ОбщиеМодули
{
	public partial class БухгалтерскиеОтчеты
	{
		//Процедура проверяет ведение однофирменности и при необходимости запрещает изменять организацию в ограничениях

		public void ПроизвестиПроверкуНаВедениеОднофирменности(/*Организация*/)
		{
			//ОргПоУмолчанию = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ПараметрыСеанса.ТекущийПользователь, "ОсновнаяОрганизация");
			if(true/*ЗначениеЗаполнено(ОргПоУмолчанию)*/)
			{
				//Организация = ОргПоУмолчанию;
			}
		}
		//Процедура рассчитывает конечные данные по начальным данным и оборотам

		public void РассчитатьКонечныеДанныеПоВидуСчетаИНачальнымДанным(/*Знач ТекущийВидСчета, ИтогДт, ИтогКт, Знач НачДт, Знач НачКт,
	Знач ОборотДт, Знач ОборотКт*/)
		{
			/*// расчет итоговой суммы
*/
			if(true/*ТекущийВидСчета = ВидСчета.Активный*/)
			{
				//ИтогДт = НачДт + ОборотДт - ОборотКт;
				//ИтогКт = 0;
			}
		}
		// Создание копии структуры или соответствия
		//
		// Параментры:
		//   СоотвИсх - Структура/Соответствие - Исходная структура, с которой будет создаваться копия.
		//
		// Возвращаемое значение:
		//   Структура/Соответствие - Копия исходной структуры. Тип данных повторяет тип исходной структуры.

		public object СоздатьКопиюСоответствияСтруктуры(/*Знач СоответствиеИсточник*/)
		{
			if(true/*СоответствиеИсточник = Неопределено*/)
			{
			}
			//КопияСоответствия = Новый (ТипЗнч(СоответствиеИсточник));
			return null;
		}
		//Функция создает по структуре параметров соответсвие

		public object СоздатьПоСтруктуреСоответствие(/*Знач СтруктураПараметров*/)
		{
			//Параметры = Новый Соответствие;
			return null;
		}
		// Управляет пометками кнопок ком. панели
		//
		// Параметры:
		//	ФормаОтчета
		//  ПоказыватьЗаголовок - булево. Отображать пометку или нет

		public void УправлениеПометкамиКнопокЗаголовковКоманднойПанели(/*ФормаОтчета, Знач ПоказыватьЗаголовок*/)
		{
			//ФормаОтчета.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.Заголовок.Пометка = ПоказыватьЗаголовок;
			//ФормаОтчета.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.Подменю.Кнопки.Заголовок.Пометка = ПоказыватьЗаголовок;
		}
		// Формирует строку ограничений по датам отчета для показа в заголовке формы
		//
		// Параметры:
		//	ДатаНач
		//  ДатаКон

		public object СформироватьСтрокуОграниченийПоДатамДляФормы(/*Знач ДатаНач, Знач ДатаКон*/)
		{
			/*// Вывод заголовка, описателя периода и фильтров и заголовка
*/
			if(true/*ДатаНач = '00010101000000' И ДатаКон = '00010101000000'*/)
			{
				//ОписаниеПериода     = "Период не установлен";
			}
			return null;
		}
		// Формирует строку ограничений по датам отчета для показа в заголовке формы
		//
		// Параметры:
		//	ДатаНач
		//  ДатаКон

		public object СформироватьСтрокуВыводаПараметровПоДатам(/*Знач ДатаНач, Знач ДатаКон*/)
		{
			if(true/*ДатаНач = '00010101000000' И ДатаКон = '00010101000000'*/)
			{
				//ОписаниеПериода     = "Период: без ограничения.";
			}
			return null;
		}
		//Функция возвращает корректные или нет ограничения по датам для отчета
		// в случае если ограничения не корректны - выдается предупреждение

		public object ПроверитьКорректностьОграниченийПоДатам(/*Знач ДатаНач, Знач ДатаКон, Знач ВыдаватьПредупреждение = Истина*/)
		{
			/*// Проверка на пустые значения
*/
			if(true/*ДатаНач > ДатаКон И ДатаКон <> '00010101000000'*/)
			{
				if(true/*ВыдаватьПредупреждение*/)
				{
					//Предупреждение("Дата начала периода не может быть больше даты конца периода");
				}
			}
			return null;
		}
		// процедура заполняет таблицу настроек свойств

		public void ЗаполнитьТаблицуНастроекСвойств(/*ЭтотОбъект, Знач ИмяРеквизита, Структура*/)
		{
			//Источник = Неопределено;
			if(true/*Структура.Свойство(ИмяРеквизита, Источник) <> Истина*/)
			{
			}
			//Приемник.Очистить();
			/*// Загрузим совпадающие колонки.
*/
		}
		// процедура обрабатывает выпод заголовка

		public void ОбработатьВыводЗаголовка(/*Форма, ОтчетОбъект, ВысотаЗаголовка, ПоказыватьЗаголовок*/)
		{
			/*// Перезаполнять заголовок можно только у "чистого" отчета
*/
			if(true/*Форма.ЭлементыФормы.ДокументРезультат.ВысотаТаблицы = 0*/)
			{
				//ОбластьЗаголовка = ОтчетОбъект.СформироватьЗаголовок();
				//ВысотаЗаголовка = ОбластьЗаголовка.ВысотаТаблицы;
				//Форма.ЭлементыФормы.ДокументРезультат.Вывести(ОбластьЗаголовка);
			}
			if(true/*ЗначениеЗаполнено(ВысотаЗаголовка)*/)
			{
				//Форма.ЭлементыФормы.ДокументРезультат.Область("R1:R" + ВысотаЗаголовка).Видимость = ПоказыватьЗаголовок;
			}
			//УправлениеПометкамиКнопокЗаголовковКоманднойПанели(Форма, ПоказыватьЗаголовок);
		}
		//процедура формирует заголовок отчета

		public void СформироватьИВывестиЗаголовокОтчета(/*ОтчетОбъект, ДокументРезультат, ВысотаЗаголовка, ПоказыватьЗаголовок*/)
		{
			//ОбластьЗаголовка = ОтчетОбъект.СформироватьЗаголовок();
			//ВысотаЗаголовка = ОбластьЗаголовка.ВысотаТаблицы;
			//ДокументРезультат.Вывести(ОбластьЗаголовка, 1);
			if(true/*ЗначениеЗаполнено(ВысотаЗаголовка)*/)
			{
				//ДокументРезультат.Область("R1:R" + ВысотаЗаголовка).Видимость = ПоказыватьЗаголовок;
			}
		}
		// Редактирование Субконто

		public void РедактированиеСубконто(/*Элемент, СписокСубконто*/)
		{
			//Форма = ПолучитьОбщуюФорму("ФормаНастройкаПоСубконто", Элемент);
			/*// Передача параметров в форму
*/
			//Форма.Список = СписокСубконто;
			//Форма.РежимВыбора = Истина;
			//Форма.ОткрытьМодально();
		}
		// обработка редактирования субконто

		public void ОбработкаРедактированиеСубконто(/*Элемент, ТекущиеДанныеТаблицыРедактирования*/)
		{
			if(true/*ТекущиеДанныеТаблицыРедактирования = Неопределено*/)
			{
			}
			//Счет = ТекущиеДанныеТаблицыРедактирования.Счет;
			if(true/*НЕ ЗначениеЗаполнено(Счет)*/)
			{
				//Предупреждение("Не выбран счет!");
			}
			//СписокСубконто = Новый СписокЗначений;
			/*// Данные этой строки должны быть отмечены
*/
			//РедактированиеСубконто(Элемент, СписокСубконто);
		}
		//процедура очищает данные разворота по субконто текущей строки настроек

		public void ОчиститьДанныеНастроекПоСубконтоДляТекущейСтрокиНастроек(/*РедактируемаяСтрока*/)
		{
			//РедактируемаяСтрока.РазворотПоСубконто.Очистить();
			if(true/*РедактируемаяСтрока.РазворотПоСубконто.Колонки.Количество() = 0*/)
			{
				//ОписаниеТиповСтрока = Новый ОписаниеТипов("Строка",, Новый КвалификаторыСтроки(100));
				//РедактируемаяСтрока.РазворотПоСубконто.Колонки.Добавить("Имя",           ОписаниеТиповСтрока);
				//РедактируемаяСтрока.РазворотПоСубконто.Колонки.Добавить("Представление", ОписаниеТиповСтрока);
			}
			//РедактируемаяСтрока.ПредставлениеРазворотПоСубконто = "";
		}
		//процедура добавляет новое значение субконто в список выбранных

		public void ДобавитьСубконтоВТаблицуВыбранных(/*ТаблицаВыбораСубконто, Знач ИмяСубконто, Знач ПредставлениеСубконто*/)
		{
			//НоваяСтрокаПоСубконто = ТаблицаВыбораСубконто.РазворотПоСубконто.Добавить();
			//НоваяСтрокаПоСубконто.Имя = ИмяСубконто;
			//НоваяСтрокаПоСубконто.Представление = ПредставлениеСубконто;
			/*ТаблицаВыбораСубконто.ПредставлениеРазворотПоСубконто = ТаблицаВыбораСубконто.ПредставлениеРазворотПоСубконто + ", " 
		+ ПредставлениеСубконто;*/
		}
		// Процедура обрабатывает выбор показателей, группировок или фильтров из отдельного окна.

		public void ОбработкаВыборРазворотаПоСубконто(/*ВыбранноеЗначение, ТабличноеПоле, СтандартнаяОбработка*/)
		{
			//СтандартнаяОбработка = Ложь;
			if(true/*ТабличноеПоле.ТекущиеДанные = Неопределено*/)
			{
			}
			//ОчиститьДанныеНастроекПоСубконтоДляТекущейСтрокиНастроек(ТабличноеПоле.ТекущиеДанные);
			//ТабличноеПоле.ТекущиеДанные.ПредставлениеРазворотПоСубконто  = Сред(ТабличноеПоле.ТекущиеДанные.ПредставлениеРазворотПоСубконто, 3);
		}
		// процедура обрабатывает окончание редактирования настроек развернутого сальдо

		public void ПриОкончанииРедактированияПравилаРазвернутогоСальдо(/*Элемент, НоваяСтрока, ОтменаРедактирования*/)
		{
			//ТабличноеПоле = Элемент;
			if(true/*ТабличноеПоле.ТекущиеДанные = Неопределено*/)
			{
			}
			if(true/*НРег(ТабличноеПоле.ТекущаяКолонка.Имя) = НРег("Субсчета")*/)
			{
				if(true/*ТабличноеПоле.ТекущиеДанные.Субсчета*/)
				{
					//ОчиститьДанныеНастроекПоСубконтоДляТекущейСтрокиНастроек(ТабличноеПоле.ТекущиеДанные);
				}
			}
		}
		// процедура - обработчик при изменении счета в таблицах детализации или развернутого сальдо

		public void ОбработчикПриИзмененииСчета(/*ТабличноеПоле, Знач ТабПолеРазвернутогоСальдо*/)
		{
			//РедактируемаяСтрока = ТабличноеПоле.ТекущиеДанные;
			if(true/*РедактируемаяСтрока = Неопределено*/)
			{
			}
			//ОчиститьДанныеНастроекПоСубконтоДляТекущейСтрокиНастроек(РедактируемаяСтрока);
			/*// Признак того, что счет найден способ развернуть счет
*/
			//НайденСпособРазворота = Ложь;
			//Счет = РедактируемаяСтрока.Счет;
			if(true/*ЗначениеЗаполнено(Счет)*/)
			{
				//ВыборкаПоСчету = ПланыСчетов[Счет.Метаданные().Имя].Выбрать(Счет);
				if(true/*ВыборкаПоСчету.Следующий()*/)
				{
					//РедактируемаяСтрока.Субсчета = Истина;
					//НайденСпособРазворота = Истина;
				}
				/*// Развернутое сальдо только по субсчетам
*/
				if(true/*ТабПолеРазвернутогоСальдо 
			И НайденСпособРазворота*/)
				{
				}
				if(true/*Счет.ВидыСубконто.Количество() > 0*/)
				{
					/*// Развернутое сальдо - отключим субсчета
*/
					if(true/*ТабПолеРазвернутогоСальдо*/)
					{
						//РедактируемаяСтрока.Субсчета = Ложь;
					}
					//РедактируемаяСтрока.ПредставлениеРазворотПоСубконто  = Сред(РедактируемаяСтрока.ПредставлениеРазворотПоСубконто, 3);
					//НайденСпособРазворота = Истина;
				}
				/*// Если у счета нет ни субсчетов, ни субконто, не дадим его выбрать.
*/
				if(true/*НЕ НайденСпособРазворота*/)
				{
					if(true/*ТабПолеРазвернутогоСальдо*/)
					{
						//ВидНастройки = "развернутого сальдо ";
					}
					//Предупреждение("Счет """ + Счет.Код + """ не имеет ни субсчетов, ни субконто." + Символы.ПС + "Настройка " + ВидНастройки + "не имеет смысла!");
					//РедактируемаяСтрока.Счет = Неопределено;
				}
			}
		}
		// процедура обработки очистки разворота по субконто

		public void ОбработкаОчисткиРазворотПоСубконтоТабПоля(/*ТабличноеПоле*/)
		{
			if(true/*ТабличноеПоле.ТекущиеДанные = Неопределено*/)
			{
			}
			//ОчиститьДанныеНастроекПоСубконтоДляТекущейСтрокиНастроек(ТабличноеПоле.ТекущиеДанные);
		}
		// процедура устанавливает связывание данных и визуальных объектов отображения
		// настроек Бух отчетов

		public void УстановитьСвязываниеДанныхФормыНастроек(/*ПравилаВыводаИтогов, ПравилаРазвернутогоСальдо*/)
		{
			/*// Связывание с данными колонок "Счет": тип определяется типом колонки у таблицы
*/
			if(true/*ПравилаВыводаИтогов <> Неопределено*/)
			{
				//ПравилаВыводаИтогов.Колонки.Счет.Данные = "Счет";
				//ПравилаВыводаИтогов.Колонки.Счет.ЭлементУправления.КнопкаВыбора = Истина;
				//ПравилаВыводаИтогов.Колонки.Счет.ЭлементУправления.КнопкаОчистки = Ложь;
				//ПравилаВыводаИтогов.Колонки.ПредставлениеРазворотПоСубконто.ЭлементУправления.КнопкаОчистки = Истина;
			}
			if(true/*ПравилаРазвернутогоСальдо <> Неопределено*/)
			{
				//ПравилаРазвернутогоСальдо.Колонки.Счет.Данные = "Счет";
				//ПравилаРазвернутогоСальдо.Колонки.Счет.ЭлементУправления.КнопкаВыбора = Истина;
				//ПравилаРазвернутогоСальдо.Колонки.Счет.ЭлементУправления.КнопкаОчистки = Ложь;
				//ПравилаРазвернутогоСальдо.Колонки.ПредставлениеРазворотПоСубконто.ЭлементУправления.КнопкаОчистки = Истина;
			}
		}
		// процедура содает колонки у таблиц правила вывода итогов и правила развернутого сальдо

		public void СоздатьКолонкиУПравилВыводаИтоговИПравилаРазвернутогоСальдо(/*ПравилаВыводаИтогов, ПравилаРазвернутогоСальдо, 
	Знач ИмяРегистраБухгалтерии*/)
		{
			//ОписаниеТиповСтрока = Новый ОписаниеТипов("Строка",, Новый КвалификаторыСтроки(200));
			//МассивБулево        = Новый Массив;
			//ОписаниеТиповБулево = Новый ОписаниеТипов("Булево");
			//МассивТаблицаЗначений        = Новый Массив;
			//ОписаниеТиповТаблицаЗначений = Новый ОписаниеТипов("ТаблицаЗначений");
			//МассивСчет = Новый Массив;
			//МассивСчет.Добавить(ТипЗнч(ПланыСчетов[Метаданные.РегистрыБухгалтерии[ИмяРегистраБухгалтерии].ПланСчетов.Имя].ПустаяСсылка()));
			//ОписаниеТиповСчет  = Новый ОписаниеТипов(МассивСчет);
			/*// Создание структуры реквизитов - таблиц
*/
			if(true/*ПравилаВыводаИтогов <> Неопределено*/)
			{
				//ПравилаВыводаИтогов.Колонки.Очистить();
				//ПравилаВыводаИтогов.Колонки.Добавить("Счет",     ОписаниеТиповСчет);
				//ПравилаВыводаИтогов.Колонки.Добавить("Субсчета", ОписаниеТиповБулево);
				//ПравилаВыводаИтогов.Колонки.Добавить("ПредставлениеРазворотПоСубконто", ОписаниеТиповСтрока);
				//ПравилаВыводаИтогов.Колонки.Добавить("РазворотПоСубконто", ОписаниеТиповТаблицаЗначений);
			}
			if(true/*ПравилаРазвернутогоСальдо <> Неопределено*/)
			{
				//ПравилаРазвернутогоСальдо.Колонки.Очистить();
				//ПравилаРазвернутогоСальдо.Колонки.Добавить("Счет",     ОписаниеТиповСчет);
				//ПравилаРазвернутогоСальдо.Колонки.Добавить("Субсчета", ОписаниеТиповБулево);
				//ПравилаРазвернутогоСальдо.Колонки.Добавить("ПредставлениеРазворотПоСубконто", ОписаниеТиповСтрока);
				//ПравилаРазвернутогоСальдо.Колонки.Добавить("РазворотПоСубконто", ОписаниеТиповТаблицаЗначений);
			}
		}
		//Функция возвращает есть ли для данного счета субсчета или нет

		public object ОпределитьНаличиеСубсчетов(/*Знач ИмяПланаСчетов, Знач Счет*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(Счет)*/)
			{
			}
			/*ТекстЗапроса = 
	"ВЫБРАТЬ
	|	Родители.Ссылка
	|ИЗ
	|	ПланСчетов." + ИмяПланаСчетов + " КАК Родители
	|		ВНУТРЕННЕЕ СОЕДИНЕНИЕ ПланСчетов." + ИмяПланаСчетов + " КАК Дети
	|		ПО Родители.Ссылка = Дети.Родитель
	|ГДЕ
	|	Родители.Ссылка = &Счет";*/
			//Запрос = Новый Запрос(ТекстЗапроса);
			//Запрос.УстановитьПараметр("Счет", Счет);
			//Результат = Запрос.Выполнить();
			//ЕстьСубсчета = Не Результат.Пустой();
			return null;
		}
		//функция возвращает соотвествие подчиненных счетов

		public object ВернутьСоответвиеПодчиненныхСчетов(/*Знач ИмяПланаСчетов = "", Знач Счет, Знач ДобавлятьСамСчетВСоответсвие = Ложь*/)
		{
			//СоответсвиеСчетов = Новый Соответствие;
			//Запрос = Новый Запрос();
			/*Запрос.Текст =
		"ВЫБРАТЬ РАЗРЕШЕННЫЕ ПланСчетовРегистра.Ссылка КАК Ссылка
		|ИЗ	ПланСчетов." + ИмяПланаСчетов + " КАК ПланСчетовРегистра
		|ГДЕ	ПланСчетовРегистра.Ссылка В Иерархии(&Ссылка)";*/
			//Запрос.УстановитьПараметр("Ссылка", Счет);
			//Выборка = Запрос.Выполнить().Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				if(true/*(НЕ ДобавлятьСамСчетВСоответсвие)
			И (Выборка.Ссылка = Счет)*/)
				{
				}
				//СоответсвиеСчетов.Вставить(Выборка.Ссылка, Выборка.Ссылка);
			}
			return null;
		}
		//Функция возвращает соответствие счетов предков

		public object ВернутьСоответвиеСчетовПредков(/*Знач ИмяПланаСчетов = "", Знач Счет*/)
		{
			/*ЗапросСчета = Новый Запрос(
		"ВЫБРАТЬ РАЗРЕШЕННЫЕ
		|	ПланСчетовРегистра.Ссылка КАК Ссылка
		|ИЗ
		|	ПланСчетов."+ИмяПланаСчетов+" КАК ПланСчетовРегистра
		|
		|ГДЕ
		|	ПланСчетовРегистра.Ссылка = &Ссылка
		|
		|ИТОГИ ПО
		|	Ссылка ИЕРАРХИЯ");*/
			//ЗапросСчета.УстановитьПараметр("Ссылка", Счет);
			//ВыборкаСчета = ЗапросСчета.Выполнить().Выбрать(ОбходРезультатаЗапроса.Прямой);
			//СоответсвиеСчетов = Новый Соответствие();
			while(true/*ВыборкаСчета.Следующий()*/)
			{
				//СоответсвиеСчетов.Вставить(ВыборкаСчета.Ссылка, ВыборкаСчета.Ссылка);
			}
			return null;
		}
		// Функция проверяет выборку на наличие ненулевых оборотов

		public object ЭтоНулевойОборот(/*Выборка, ПоКоличеству*/)
		{
			//СуммаНоль = Выборка.СуммаОборотДт = 0 И Выборка.СуммаОборотКт = 0;
			//КоличествоНоль = Не ПоКоличеству ИЛИ Выборка.КоличествоОборотДт = 0 И Выборка.КоличествоОборотКт = 0;
			return null;
		}
		//Функция для счета возвращает количество субконто для него

		public object ОпределитьДляСчетаПоСоответсвиеКоличествоСубконто(/*Знач Счет, СоответсвиеСчетов*/)
		{
			//СоответсвиеСчетов = Новый Соответствие;
			//КоличествоСубконтоСчета = СоответсвиеСчетов[Счет];
			if(true/*КоличествоСубконтоСчета = -1
		ИЛИ КоличествоСубконтоСчета = Неопределено*/)
			{
				//КоличествоСубконтоСчета = Счет.ВидыСубконто.Количество();
				//СоответсвиеСчетов[Счет] = КоличествоСубконтоСчета;
			}
			return null;
		}
		// процедура выводит представления субконто для текущей строки отчета в макет

		public void ВывестиПредставленияСубконтоТекущейСтрокиВМакет(/*Знач ПрефиксНаименованияКолонки, Проводки, Знач КоличествоСубконтоСчета, 
	ОбластьМакет, ДокументРезультат, СтруктураРасшифровки*/)
		{
		}
		//Функция определяещая наличие дублирующегося параметра детализации

		public object ОпределитьНаличиеДублирующегосяПараметраВИзмерениях(/*ПостроительОтчета*/)
		{
			//СоответствиеТекущихИзмерений = Новый Соответствие;
			return null;
		}
		//Процедура формирует первоначальные строки отбора построителя по субконто

		public void СформироватьПервоначальныйОтборПостроителяПоСубконто(/*ПостроительОтчета, Знач Счет*/)
		{
			//ПостроительОтчета.ИзмеренияСтроки.Очистить();
			//Сч = 0;
		}

		public object ПолучитьТипИзмеренияПоУмолчанию(/*ТипЗначения*/)
		{
			return null;
		}

		public object ПолучитьТипИзмеренияПостроителяОтчетаПоУмолчанию(/**/)
		{
			//ТипДетализацииПоУмолчанию = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ПараметрыСеанса.ТекущийПользователь, "ТипДетализацииСтандартныхОтчетов");
			if(true/*ТипДетализацииПоУмолчанию = Перечисления.ТипДетализацииСтандартныхОтчетов.Элементы*/)
			{
			}
			return null;
		}

		public void УстановитьТипИзмеренияПоУмолчанию(/*ТекущиеДанные, ПостроительОтчета*/)
		{
			//ПутьКДанным = ТекущиеДанные.ПутьКДанным;
			if(true/*Найти(ПутьКДанным, "КорСубконто") > 0*/)
			{
				//Префикс = "КорСубконто";
			}
			//ИндексВидСубконто = Число(Сред(ПутьКДанным, СтрДлина(Префикс) + 1, 1)) - 1;
			//Путь = СтрЗаменить(ПутьКДанным, ".", ".Поля.");
			//ТипЗначения = Неопределено;
			//Выполнить("ТипЗначения = ПостроительОтчета.ДоступныеПоля." + Путь + ".ТипЗначения");
			//ТекущиеДанные.ТипИзмерения = ПолучитьТипИзмеренияПоУмолчанию(ТипЗначения);
		}
		// процедура устанавливает отбор посторителю отчетов по параметрам

		public void ВосстановитьОтборПостроителяОтчетовПоПараметрам(/*ПостроительОтчета, Знач СтрокиОтбора*/)
		{
			if(true/*СтрокиОтбора = Неопределено*/)
			{
			}
			if(true/*ТипЗнч(СтрокиОтбора) = Тип("Соответствие")
		ИЛИ ТипЗнч(СтрокиОтбора) = Тип("Структура")*/)
			{
			}
		}
		//Функция формирует описание ограничений по измерениям построителя

		public object СформироватьСтрокуОписанияИтоговПоИзмерениямПостроителя(/*ПостроительОтчета*/)
		{
			if(true/*ПостроительОтчета.ИзмеренияСтроки.Количество() = 0*/)
			{
			}
			//ТекстПроИтоги = "субконто: ";
			//СтрокаИзмерений = "";
			//ТекстПроИтоги = ТекстПроИтоги + Сред(СтрокаИзмерений, 3);
			return null;
		}
		///////////////////////////////////////////////////////////////////////////////
		//ОБОРОТНО-САЛЬДОВАЯ ВЕДОМОСТЬ
		///////////////////////////////////////////////////////////////////////////////
		//функция возвращает структуру форматов показателей по массиву показателей

		public object СформироватьСтруктуруФорматовПоказателей(/*Знач МассивПоказателей, Знач ИмяРегистраБухгалтерии*/)
		{
			//ФорматПоказателей = Новый Структура();
			return null;
		}
		//Функция возвращает видсубконто по имени

		public object ВернутьСубконтоПоИмени(/*Знач Счет, Знач ИмяСубконто*/)
		{
			/*// Найдем соответствующий вид субконто
*/
			return null;
		}
		//Функция возвращает можно ил использовать составной запрос для детализации по субконто

		public object ОпределитьМожноИспользоватьСоставнойЗапросПоСубконто(/*ПравилаСчета*/)
		{
			/*// Определим признак использования составного запроса
*/
			return null;
		}
		//Процедура формирует строку ограничений для выборки из таблицы оборотов и остатков регистров бухгалтерии

		public void ДополнитьСтрокуОграниченийПоРеквизитам(/*СтрокаОграничения, Знач ИмяОграниченияПоРеквизиту, Знач ОграничениеПоРеквизиту*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(ОграничениеПоРеквизиту) и не ТипЗнч(ОграничениеПоРеквизиту) = Тип("СправочникСсылка.СценарииПланирования")*/)
			{
			}
			//СтрокаНовогоОграничения = ИмяОграниченияПоРеквизиту + " = &" + ИмяОграниченияПоРеквизиту + " ";
			//СтрокаОграничения = ОбъединитьОграничения(СтрокаОграничения, СтрокаНовогоОграничения);
		}
		//Функция Объединяет ограничения

		public object ОбъединитьОграничения(/*Знач Ограничение1, Знач Ограничение2, Знач СтрокаОбъединенияОграничений = "И"*/)
		{
			if(true/*ПустаяСтрока(Ограничение1)*/)
			{
			}
			if(true/*ПустаяСтрока(Ограничение2)*/)
			{
			}
			//СтрокаОграничения = Ограничение1 + " " + СтрокаОбъединенияОграничений + " " + Ограничение2;
			return null;
		}
		//Функция формирует текст строки запроса для выборки данных оборотов и остатков регистра бухгалтерии

		public object СформироватьТекстВыборкиИзТаблицыОборотовИОстатковРегистраБухгалтерии(/*СтруктураПараметров, 
	Знач ИмяАлиасаТаблицы = "ОстаткиИОбороты", Знач ДопОграничениеПоСчету = "" */)
		{
			//СтрокаОграниченийПоРеквизитам = "";
			//ДополнитьСтрокуОграниченийПоРеквизитам(СтрокаОграниченийПоРеквизитам, "Организация", СтруктураПараметров.СтруктураОграничений.Организация);
			//ДополнитьСтрокуОграниченийПоРеквизитам(СтрокаОграниченийПоРеквизитам, "ВидУчета", СтруктураПараметров.СтруктураОграничений.ВидУчета);
			//ДополнитьСтрокуОграниченийПоРеквизитам(СтрокаОграниченийПоРеквизитам, "ОтражениеВНУ", СтруктураПараметров.СтруктураОграничений.ОтражениеВНУ);
			//ДополнитьСтрокуОграниченийПоРеквизитам(СтрокаОграниченийПоРеквизитам, "Валюта", СтруктураПараметров.СтруктураОграничений.Валюта);
			//ДополнитьСтрокуОграниченийПоРеквизитам(СтрокаОграниченийПоРеквизитам, "Сценарий", СтруктураПараметров.СтруктураОграничений.Сценарий);
			//СтрокаСвязкиДопОграниченияПоСчету = ?(ПустаяСтрока(ДопОграничениеПоСчету), "", " И ");
			/*СтрокаЧастиЗапроса = "
			|ИЗ
			|	РегистрБухгалтерии." + СтруктураПараметров.СтруктураОграничений.ИмяРегистраБухгалтерии + ".ОстаткиИОбороты( "
			+ ?(СтруктураПараметров.СтруктураОграничений.ДатаНач = '00010101000000', "", "&НачПериода") + ", "
			+ ?(СтруктураПараметров.СтруктураОграничений.ДатаКон = '00010101000000', "", "&КонПериода") 
			+ ", , , " + ДопОграничениеПоСчету  
			+ ?(СтруктураПараметров.СтруктураОграничений.ИспользоватьОграниченияПоЗабалансовымСчетам = Ложь 
				ИЛИ СтруктураПараметров.СтруктураОграничений.ПоЗабалансовымСчетам = Истина, "", СтрокаСвязкиДопОграниченияПоСчету + " НЕ Счет.Забалансовый ") + ", "
			+ ", "
			+ СтрокаОграниченийПоРеквизитам + ") КАК " + ИмяАлиасаТаблицы;*/
			return null;
		}
		//Функция дополняет текст часть сформированного запроса по определенным полям

		public object ВернутьЧастьЗапросаПоВыборкеПолейОборотноСальдоваяВедомость(/*МассивПоказателей, Знач ПоляДляВыборки = Истина, 
		Знач ИспользоватьАлиасыПолей = Ложь, Знач ИспользоватьВКачествеПрефиксаАлиасаИмяПоказателя = Ложь, ПолучатьРазвернутыйОстаток = Ложь*/)
		{
			//СтрокаЗапроса = "";
			//РазвернутыйОстаток = ?(ПолучатьРазвернутыйОстаток, "Развернутый", "");
			if(true/*ПоляДляВыборки*/)
			{
				if(true/*ИспользоватьАлиасыПолей*/)
				{
					/*// выборка с алиасами
*/
				}
			}
			return null;
		}
		//Функция возвращает часть запроса для иерархического вывода результатов отчета

		public object ПолучитьПоТипуИзмеренияПостроителяОтчетаСтрокуЗапроса(/*Знач ТипИзмерения*/)
		{
			if(true/*ТипИзмерения = ТипИзмеренияПостроителяОтчета.Иерархия*/)
			{
			}
			return null;
		}
		// Формирует запросы по каждому счету, указанному в таблице вывода итогов
		//
		// Параметры:
		//	Нет.
		//
		// Возвращаемое значение:
		//	Таблица запросов
		//

		public object СформироватьТаблицуДанныхРазворотаСчетов(/*СтруктураПараметров, Знач ПравилаВыводаИтогов*/)
		{
			/*// Результат функции будут укладываться в таблицу
*/
			//ТаблицаРазворотаСчетов = Новый ТаблицаЗначений;
			//ТаблицаРазворотаСчетов.Колонки.Добавить("Счет");
			//ТаблицаРазворотаСчетов.Колонки.Добавить("Результат");
			//ТаблицаРазворотаСчетов.Колонки.Добавить("МассивГруппировок");
			//ТаблицаРазворотаСчетов.Колонки.Добавить("СоответсвиеСчетов");
			if(true/*НЕ СтруктураПараметров.СтруктураОграничений.ПоСубсчетамИСубконто
		ИЛИ ПравилаВыводаИтогов.Количество() = 0*/)
			{
			}
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("НачПериода", НачалоДня(СтруктураПараметров.СтруктураОграничений.ДатаНач));
			//Запрос.УстановитьПараметр("КонПериода", КонецДня(СтруктураПараметров.СтруктураОграничений.ДатаКон));
			//Запрос.УстановитьПараметр("Организация", СтруктураПараметров.СтруктураОграничений.Организация);
			//Запрос.УстановитьПараметр("ВидУчета", СтруктураПараметров.СтруктураОграничений.ВидУчета);
			//Запрос.УстановитьПараметр("Валюта",  СтруктураПараметров.СтруктураОграничений.Валюта);
			//Запрос.УстановитьПараметр("ОтражениеВНУ",  СтруктураПараметров.СтруктураОграничений.ОтражениеВНУ);
			//Запрос.УстановитьПараметр("Сценарий",  СтруктураПараметров.СтруктураОграничений.Сценарий);
			/*// Сформируем текст запроса
*/
			return null;
		}
		// Формирует запросы по каждому из счетов, указанному в таблице развернутого сальдо
		//
		// Параметры:
		//	Нет.
		//
		// Возвращаемое значение:
		//	Таблица запросов
		//

		public object СформироватьТаблицуДанныхРазвернутогоСальдо(/*СтруктураПараметров, ПравилаРазвернутогоСальдо*/)
		{
			/*// Результат Каждого запроса будет укладываться в специальную таблицу
*/
			//ТаблицаРазвернутогоСальдо = Новый ТаблицаЗначений;
			//ТаблицаРазвернутогоСальдо.Колонки.Добавить("Счет");
			//ТаблицаРазвернутогоСальдо.Колонки.Добавить("Результат");
			if(true/*НЕ СтруктураПараметров.СтруктураОграничений.ВыводитьРазвернутоеСальдо
		ИЛИ (ПравилаРазвернутогоСальдо.Количество() = 0)*/)
			{
			}
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("НачПериода", НачалоДня(СтруктураПараметров.СтруктураОграничений.ДатаНач));
			//Запрос.УстановитьПараметр("КонПериода", КонецДня(СтруктураПараметров.СтруктураОграничений.ДатаКон));
			//Запрос.УстановитьПараметр("Организация", СтруктураПараметров.СтруктураОграничений.Организация);
			//Запрос.УстановитьПараметр("ВидУчета", СтруктураПараметров.СтруктураОграничений.ВидУчета);
			//Запрос.УстановитьПараметр("Валюта",  СтруктураПараметров.СтруктураОграничений.Валюта);
			//Запрос.УстановитьПараметр("ОтражениеВНУ",  СтруктураПараметров.СтруктураОграничений.ОтражениеВНУ);
			//Запрос.УстановитьПараметр("Сценарий",  СтруктураПараметров.СтруктураОграничений.Сценарий);
			/*// Сформируем текст запроса
*/
			return null;
		}
		//Функция формирует структуру параметров ограничений для оборотно-сальдовой ведомости

		public object СформироватьСтруктуруОграниченийДляОборотноСальдовойВедомости(/*ОбъектОтчета,
		Знач ПоВалютам, Знач ИспользоватьОграниченияПоЗабалансовымСчетам, Знач ПоЗабалансовымСчетам = Ложь, 
		Знач ВидУчета = Неопределено, Знач Валюта = Неопределено, Знач ОтражениеВНУ = Неопределено,
		Знач Сценарий = Неопределено, Знач ВВалютеСценария = Неопределено*/)
		{
			//Структура = Новый Структура();
			//Структура.Вставить("ДатаНач", ОбъектОтчета.ДатаНач);
			//Структура.Вставить("ДатаКон", ОбъектОтчета.ДатаКон);
			//Структура.Вставить("ПоСубсчетамИСубконто", ОбъектОтчета.ПоСубсчетамИСубконто);
			//Структура.Вставить("ВыводитьРазвернутоеСальдо", ОбъектОтчета.ВыводитьРазвернутоеСальдо);
			//Структура.Вставить("ПоВалютам", ПоВалютам);
			//Структура.Вставить("ИспользоватьОграниченияПоЗабалансовымСчетам", ИспользоватьОграниченияПоЗабалансовымСчетам);
			//Структура.Вставить("ПоЗабалансовымСчетам", ПоЗабалансовымСчетам);
			//Структура.Вставить("ВидУчета", ВидУчета);
			//Структура.Вставить("Валюта",  Валюта);
			//Структура.Вставить("ОтражениеВНУ",  ОтражениеВНУ);
			//Структура.Вставить("Сценарий",  Сценарий);
			//Структура.Вставить("ВВалютеСценария",  ВВалютеСценария);
			//Структура.Вставить("ИмяРегистраБухгалтерии", ОбъектОтчета.ИмяРегистраБухгалтерии);
			return null;
		}
		// процедура инициализирует структуру в которой хранятся итоговые суммы документа

		public void ИнициализироватьСтруктуруХраненияИтоговОборотка(/*Знач МассивПоказателей, СтруктураОбщийИтог*/)
		{
		}
		// процедура добавляет в итоговое хранилище сумм текущие данных

		public void ДополнитьСтруктуруХраненияИтоговОборотка(/*Знач ИмяПоказателя, СтруктураОбщийИтог,
	Знач НачальныйОстатокДт, Знач НачальныйОстатокКт, Знач КонечныйОстатокДт, Знач КонечныйОстатокКт,
	Знач ОборотДт, Знач ОборотКт*/)
		{
			//СтруктураОбщийИтог[ИмяПоказателя + "НачальныйОстатокДт"] = СтруктураОбщийИтог[ИмяПоказателя + "НачальныйОстатокДт"] + НачальныйОстатокДт;
			//СтруктураОбщийИтог[ИмяПоказателя + "НачальныйОстатокКт"] = СтруктураОбщийИтог[ИмяПоказателя + "НачальныйОстатокКт"] + НачальныйОстатокКт;
			//СтруктураОбщийИтог[ИмяПоказателя + "КонечныйОстатокДт"] =  СтруктураОбщийИтог[ИмяПоказателя + "КонечныйОстатокДт" ] + КонечныйОстатокДт;
			//СтруктураОбщийИтог[ИмяПоказателя + "КонечныйОстатокКт"] =  СтруктураОбщийИтог[ИмяПоказателя + "КонечныйОстатокКт" ] + КонечныйОстатокКт;
			//СтруктураОбщийИтог[ИмяПоказателя + "ОборотДт"] =           СтруктураОбщийИтог[ИмяПоказателя + "ОборотДт"]           + ОборотДт;
			//СтруктураОбщийИтог[ИмяПоказателя + "ОборотКт"] =           СтруктураОбщийИтог[ИмяПоказателя + "ОборотКт"]           + ОборотКт;
		}
		// процедура выводит текущие данные оборотки в область вывода

		public void ЗаполнитьДаннымОблатьВыводаОборотка(/*Область, Знач ФорматПоказателя, 
	Знач НачальныйОстатокДт, Знач НачальныйОстатокКт, 
	Знач КонечныйОстатокДт, Знач КонечныйОстатокКт, 
	Знач ОборотДт, Знач ОборотКт*/)
		{
			//Область.Параметры.НачальныйОстатокДт = Формат(НачальныйОстатокДт, ФорматПоказателя);
			//Область.Параметры.НачальныйОстатокКт = Формат(НачальныйОстатокКт, ФорматПоказателя);
			//Область.Параметры.КонечныйОстатокДт  = Формат(КонечныйОстатокДт,  ФорматПоказателя);
			//Область.Параметры.КонечныйОстатокКт  = Формат(КонечныйОстатокКт,  ФорматПоказателя);
			//Область.Параметры.ОборотДт           = Формат(ОборотДт,           ФорматПоказателя);
			//Область.Параметры.ОборотКт           = Формат(ОборотКт,           ФорматПоказателя);
		}
		// Выводит показатели
		//
		// Параметры:
		//	ДокументРезультат - таблица отчета
		//	Макет - используемый макет
		//	Результат - выборка
		//	Счет - счет выборки
		//	ЭтоПерваяСтрока - признак вывода отступов перед субконто
		//	СтрокаРазвернутогоСальдо - строка с выборкой - развернутым сальдо по счету
		//	СтруктураОбщийИтог - структура, в которой накапливается общий итог.
		//

		public void ВывестиПоказателиОборотноСальдовойВедомости(/*ДокументРезультат, Выборка, Счет, СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, СтруктураПараметров*/)
		{
			//ВыведеноПоказателей = 0;
			//ИмяГруппировки = Выборка.Группировка();
		}
		// Выводит группировку при развороте счета по субсчетам и/или субконто
		//
		// Параметры:
		//	Выборка         - выборка из результата запроса по выводимой группировке,
		//	ИндексТекущейГруппировки - индекс выводимой группировки в массиве группировок,
		//	МассивГруппировок - массив, содержащий имена группировок, по которым строится разворот счета,
		//	Уровень 		- уровень  группировки верхнего уровня
		//	СдвигУровня     - сдвиг уровня группировки отчета относительно уровня группировки запроса,
		//	СброситьСдвигУровня - признак сброса сдвига уровня,
		//	СтрокаРазвернутогоСальдо - строка таблицы значений с развернутым сальдо по текущему счету.
		//	СтруктураОбщийИтог - структура, в которой накапливаются общие итоги,
		//	ПоследнийВыведенныйСчет - последний выведенный счет,
		//	СтруктураПараметров - структура, содержащая неизменные для разворота счета параметры:
		//	                      Области макета табличного документа, линии, уровень группировки,
		//	                      с которой начался вывод отчета.
		//

		public void ВывестиГруппировкуОборотноСальдовойВедомости(/*Выборка, Знач ИндексТекущейГруппировки, МассивГруппировок, Уровень, СдвигУровня, 
	СброситьСдвигУровня, ПоследнийВыведенныйСчет, СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, СтруктураПараметров, 
	ОтборСубконто*/)
		{
			while(true/*Выборка.Следующий()*/)
			{
				//ИмяГруппировки = Выборка.Группировка();
				/*// Итоги более высокого уровня по счету - пропускаем (он уже выведен)
*/
				if(true/*ИмяГруппировки = "Счет"*/)
				{
					/*// При выводе субсчетов не делаем отступы
*/
					if(true/*СброситьСдвигУровня*/)
					{
						//СброситьСдвигУровня = Ложь;
						//СдвигУровня = 0;
					}
					//Отступ = 0;
					//СдвигУровня = СдвигУровня + 1;
					/*// Уже выведенные счета не выводим
*/
					if(true/*ПоследнийВыведенныйСчет = Выборка.Счет 
				ИЛИ ПоследнийВыведенныйСчет.ПринадлежитЭлементу(Выборка.Счет)*/)
					{
						/*ВывестиВложеннуюГруппировкуОборотноСальдовойВедомости(Выборка, ИндексТекущейГруппировки, МассивГруппировок, Уровень, СдвигУровня, 
					СброситьСдвигУровня, ПоследнийВыведенныйСчет, СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, СтруктураПараметров, ОтборСубконто);*/
					}
				}
				//ОбластьСтрокаСчет = СтруктураПараметров.ОбластьСтрокаСчет;
				//ОбластьСтрокаСчет.Параметры.Заполнить(Выборка);
				//ВыводимаяОбласть = ОбластьСтрокаСчет;
				/*// Заполнение параметров расшифровки
*/
				if(true/*ИмяГруппировки = "Счет"*/)
				{
					/*ЗаполнитьПараметрыРасшифровкиОборотноСальдовойВедомости(СтруктураПараметров.СтруктураОграничений.ДатаНач, 
				СтруктураПараметров.СтруктураОграничений.ДатаКон, СтруктураПараметров.СтруктураОграничений.ИмяРегистраБухгалтерии,
				ОбластьСтрокаСчет, Выборка, , , СтруктураПараметров.СтруктураОграничений.ВВалютеСценария);*/
				}
				if(true/*Лев(ИмяГруппировки, СтрДлина(ИмяГруппировки) - 1) = "Субконто"*/)
				{
					/*// Субконто, которых нет, равны NULL
*/
					if(true/*Выборка[ИмяГруппировки] = NULL*/)
					{
					}
					//ОбластьСтрокаПоказателяСчет = СтруктураПараметров.ОбластьСтрокаПоказателяСчет;
					//ОбластьСтрокаПоказателяСчет.Параметры.Заполнить(Выборка);
					//ОбластьСтрокаПоказателяСчет.Параметры.СубконтоПредставление = Выборка[ИмяГруппировки + "Представление"];
					//ВыводимаяОбласть = ОбластьСтрокаПоказателяСчет;
					/*ЗаполнитьПараметрыРасшифровкиОборотноСальдовойВедомости(СтруктураПараметров.СтруктураОграничений.ДатаНач, 
				СтруктураПараметров.СтруктураОграничений.ДатаКон, СтруктураПараметров.СтруктураОграничений.ИмяРегистраБухгалтерии,
				ВыводимаяОбласть, Выборка, ОтборСубконто, ПоследнийВыведенныйСчет, СтруктураПараметров.СтруктураОграничений.ВВалютеСценария);*/
					//ВыводимаяОбласть.Область(1, 4).Отступ = Отступ;
					if(true/*Выборка.ТипЗаписи() = ТипЗаписиЗапроса.ИтогПоИерархии*/)
					{
						//ВыводимаяОбласть.Область(1, 4).Шрифт = Новый Шрифт(ВыводимаяОбласть.Область(1, 4).Шрифт,,,,Истина);
					}
				}
				//ДокументРезультат = СтруктураПараметров.ДокументРезультат;
				//ДокументРезультат.Вывести(ВыводимаяОбласть, Уровень + Выборка.Уровень());
				//ВывестиПоказателиОборотноСальдовойВедомости(ДокументРезультат, Выборка, Выборка.Счет, СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, СтруктураПараметров);
				/*// вывод данных по валютам
*/
				//ОбластьСтрокаПоказателяСчет = СтруктураПараметров.ОбластьСтрокаПоказателяСчет;
				/*ВывестиДанныеПоВалютамОборотноСальдовойВедомости(СтруктураПараметров, ОбластьСтрокаПоказателяСчет, Выборка, ДокументРезультат, 
			СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, Отступ);*/
				/*ВывестиВложеннуюГруппировкуОборотноСальдовойВедомости(Выборка, ИндексТекущейГруппировки, МассивГруппировок, Уровень, СдвигУровня, 
			СброситьСдвигУровня, ПоследнийВыведенныйСчет, СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, СтруктураПараметров, ОтборСубконто);*/
			}
			//;;
		}
		//процедура выводит вложенную группировку

		public void ВывестиВложеннуюГруппировкуОборотноСальдовойВедомости(/*Выборка, Знач ИндексТекущейГруппировки, МассивГруппировок, Уровень, СдвигУровня, 
	СброситьСдвигУровня, ПоследнийВыведенныйСчет, СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, СтруктураПараметров, ОтборСубконто*/)
		{
			if(true/*ИндексТекущейГруппировки + 1 >= МассивГруппировок.Количество()*/)
			{
			}
			/*ВывестиГруппировкуОборотноСальдовойВедомости(Выборка.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам, МассивГруппировок[ИндексТекущейГруппировки + 1]), 
						ИндексТекущейГруппировки + 1, МассивГруппировок, Уровень, 
						СдвигУровня, СброситьСдвигУровня, ПоследнийВыведенныйСчет, 
						СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, СтруктураПараметров, СоздатьКопиюСоответствияСтруктуры(ОтборСубконто));*/
		}
		// процедура Выводит данные по валютам

		public void ВывестиДанныеПоВалютамОборотноСальдовойВедомости(/*СтруктураПараметров, ОбластьСтрокаПоказателяСчет, Выборка, 
	ДокументРезультат, СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, Знач Отступ*/)
		{
			/*// Если по валютам,
*/
			if(true/*СтруктураПараметров.СтруктураОграничений.ПоВалютам*/)
			{
				//ВыборкаПоВалютам = Выборка.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам, "Валюта");
				while(true/*ВыборкаПоВалютам.Следующий()*/)
				{
					//ОбластьСтрокаПоказателяСчет.Параметры.Заполнить(Выборка);
					//ОбластьСтрокаПоказателяСчет.Параметры.СубконтоПредставление = "Валюта " + ВыборкаПоВалютам["ВалютаПредставление"];
					/*// Заполнение параметров расшифровки
*/
					/*ЗаполнитьПараметрыРасшифровкиОборотноСальдовойВедомости(СтруктураПараметров.СтруктураОграничений.ДатаНач, 
				СтруктураПараметров.СтруктураОграничений.ДатаКон, СтруктураПараметров.СтруктураОграничений.ИмяРегистраБухгалтерии,
				ОбластьСтрокаПоказателяСчет, Выборка, , , СтруктураПараметров.СтруктураОграничений.ВВалютеСценария);*/
					//ОбластьСтрокаПоказателяСчет.Область(1, 4).Отступ = Отступ + 1;
					//ДокументРезультат.Вывести(ОбластьСтрокаПоказателяСчет, Выборка.Уровень());
					//ВывестиПоказателиОборотноСальдовойВедомости(ДокументРезультат, ВыборкаПоВалютам, ВыборкаПоВалютам.Счет, СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, СтруктураПараметров);
				}
				//;;
			}
		}
		// процедура формирует отчет оборотно сальдовой ведомости

		public void СформироватьОтчетОборотноСальдовойВедомости(/*ОбъектОтчета, ДокументРезультат, ПоказыватьЗаголовок = Истина, ВысотаЗаголовка = 0,
	Знач ПоВалютам, Знач ИспользоватьОграниченияПоЗабалансовымСчетам, Знач ПоЗабалансовымСчетам, 
	Знач ВидУчета = Неопределено, Знач Валюта = Неопределено, Знач ОтражениеВНУ = Неопределено, 
	Знач Сценарий = Неопределено, Знач ВВалютеСценария = Неопределено*/)
		{
			//ОграничениеПоДатамКорректно = ПроверитьКорректностьОграниченийПоДатам(ОбъектОтчета.ДатаНач, ОбъектОтчета.ДатаКон);
			if(true/*НЕ ОграничениеПоДатамКорректно*/)
			{
			}
			//ДокументРезультат.Очистить();
			//СформироватьИВывестиЗаголовокОтчета(ОбъектОтчета, ДокументРезультат, ВысотаЗаголовка, ПоказыватьЗаголовок);
			//Макет = ПолучитьОбщийМакет("ОборотноСальдоваяВедомость");
			//ЗаголовокОтчета = Макет.ПолучитьОбласть("ЗаголовокОтчета");
			//ДокументРезультат.Вывести(ЗаголовокОтчета, 1);
			//ДокументРезультат.НачатьАвтогруппировкуСтрок();
			/*// Используемые области макета
*/
			//ОбластьСтрокаСчет           = Макет.ПолучитьОбласть("Строка|Счет");
			//ОбластьСтрокаПоказателяСчет = Макет.ПолучитьОбласть("СтрокаПоказателя|Счет");
			/*// В этой структуре будут храниться постоянные значения, передаваемые во другие процедуры:
*/
			/*// - формат, 
*/
			/*// - области макета
*/
			//СтруктураПараметров = Новый Структура;
			/*// Переменная, содержащая имена показателей отчета (ресурсов) в виде массива
*/
			//МассивПоказателей = ОбъектОтчета.СформироватьМассивПоказателей();
			//СтруктураПараметров.Вставить("МассивПоказателей", МассивПоказателей);
			/*// Области для вывода показателей
*/
			//СтруктураПараметров.Вставить("ОбластьСтрокаПоказателяЧисла",Макет.ПолучитьОбласть("СтрокаПоказателя|Числа"));
			//СтруктураПараметров.Вставить("ОбластьСтрокаЧисла",          Макет.ПолучитьОбласть("Строка|Числа"));
			//СтруктураПараметров.Вставить("ОбластьСтрокаПоказателяСчет", Макет.ПолучитьОбласть("СтрокаПоказателя|Счет"));
			/*// Линии, используемые при выводе
*/
			//СтруктураПараметров.Вставить("НетЛинии",    Новый Линия(ТипЛинииЯчейкиТабличногоДокумента.НетЛинии, 1));
			/*// Формат показателей
*/
			//СтруктураФорматовПоказателей = СформироватьСтруктуруФорматовПоказателей(МассивПоказателей, ОбъектОтчета.ИмяРегистраБухгалтерии);
			//СтруктураПараметров.Вставить("ФорматПоказателей", СтруктураФорматовПоказателей);
			/*СтруктураПараметровОграничений = СформироватьСтруктуруОграниченийДляОборотноСальдовойВедомости(ОбъектОтчета,
		ПоВалютам, ИспользоватьОграниченияПоЗабалансовымСчетам, ПоЗабалансовымСчетам, ВидУчета, Валюта, ОтражениеВНУ, 
		Сценарий, ВВалютеСценария);*/
			//СтруктураПараметров.Вставить("СтруктураОграничений", СтруктураПараметровОграничений);
			//СтруктураОбщийИтог = Новый Структура;
			//ИнициализироватьСтруктуруХраненияИтоговОборотка(МассивПоказателей, СтруктураОбщийИтог);
			//СоотвПодчСчета = Новый Соответствие;
			//Запрос = ОбъектОтчета.СформироватьЗапрос(СтруктураПараметров);
			/*// Рассчитаем итоги по счетам, заданным в таблице вывода итогов по счетам
*/
			//ТаблицаРазворотаСчетов = СформироватьТаблицуДанныхРазворотаСчетов(СтруктураПараметров, ОбъектОтчета.ПравилаВыводаИтогов);
			//ТаблицаРазворотаСчетов.Индексы.Добавить("Счет");
			/*// Рассчитаем итоги по счетам, заданным в таблице развернутого сальдо
*/
			//ТаблицаРазвернутогоСальдо = СформироватьТаблицуДанныхРазвернутогоСальдо(СтруктураПараметров, ОбъектОтчета.ПравилаРазвернутогоСальдо);
			//ТаблицаРазвернутогоСальдо.Индексы.Добавить("Счет");
			//РезультатЗапроса = Запрос.Выполнить();
			//Выборка = РезультатЗапроса.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам, "Счет");
			while(true/*Выборка.Следующий()*/)
			{
				//Уровень = Выборка.Уровень();
				if(true/*НЕ ОбъектОтчета.ПоСубсчетамИСубконто
			И Уровень > 0*/)
				{
				}
				/*// Пропускаем подчиненные счета разворачиваемого счета
*/
				if(true/*СоотвПодчСчета[Выборка.Счет] <> Неопределено*/)
				{
				}
				//ОбластьСтрокаСчет.Параметры.Заполнить(Выборка);
				/*// Заполнение параметров расшифровки
*/
				/*ЗаполнитьПараметрыРасшифровкиОборотноСальдовойВедомости(ОбъектОтчета.ДатаНач, ОбъектОтчета.ДатаКон, 
			ОбъектОтчета.ИмяРегистраБухгалтерии, ОбластьСтрокаСчет, Выборка, , , ВВалютеСценария);*/
				/*// выводим текущую строку отчета
*/
				//ДокументРезультат.Вывести(ОбластьСтрокаСчет, Уровень);
				/*// Определим, нужно ли выводить развернутое сальдо по счету и
*/
				/*// разворачивать счет по субконто
*/
				if(true/*ОбъектОтчета.ВыводитьРазвернутоеСальдо*/)
				{
					//СтрокаРазвернутогоСальдо = ТаблицаРазвернутогоСальдо.Найти(Выборка.Счет, "Счет");
				}
				if(true/*ОбъектОтчета.ПоСубсчетамИСубконто*/)
				{
					//СтрокаРазворотаСчета = ТаблицаРазворотаСчетов.Найти(Выборка.Счет, "Счет");
				}
				//ВывестиПоказателиОборотноСальдовойВедомости(ДокументРезультат, Выборка, Выборка.Счет, СтрокаРазвернутогоСальдо, СтруктураОбщийИтог, СтруктураПараметров);
				/*ВывестиДанныеПоВалютамОборотноСальдовойВедомости(СтруктураПараметров, ОбластьСтрокаПоказателяСчет, Выборка, ДокументРезультат, СтрокаРазвернутогоСальдо, 
			СтруктураОбщийИтог, -1);*/
				/*// Вывод разворота счета по субконто
*/
				if(true/*СтрокаРазворотаСчета <> Неопределено*/)
				{
					//СтрокаРазвернутогоСальдо = Неопределено;
					//СоотвПодчСчета = СтрокаРазворотаСчета.СоответсвиеСчетов;
					/*// Сдвиг уровня выводимой группировки отчета относительно группировки запроса
*/
					//СдвигУровня = 0;
					/*// Флаг сброса сдвига уровня при выводе группировки по счету
*/
					//СброситьСдвигУровня = Истина;
					//ВыборкаПоСчету = СтрокаРазворотаСчета.Результат.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам, СтрокаРазворотаСчета.МассивГруппировок[0]);
					//СтруктураПараметров.Вставить("ОбластьСтрокаСчет",           ОбластьСтрокаСчет);
					//СтруктураПараметров.Вставить("ОбластьСтрокаПоказателяСчет", ОбластьСтрокаПоказателяСчет);
					//СтруктураПараметров.Вставить("ДокументРезультат", ДокументРезультат);
					/*//вывод детализированных данных
*/
					/*ВывестиГруппировкуОборотноСальдовойВедомости(ВыборкаПоСчету, 0, СтрокаРазворотаСчета.МассивГруппировок, 
				Уровень, СдвигУровня, СброситьСдвигУровня, 
				Выборка.Счет, СтрокаРазвернутогоСальдо, 
				СтруктураОбщийИтог, СтруктураПараметров, Новый Соответствие);*/
				}
			}
			/*;

	ДокументРезультат.ЗакончитьАвтогруппировкуСтрок();*/
			/*// Выведем итоговую строку
*/
			//ОбластьИтогиСчет = Макет.ПолучитьОбласть("Итоги|Счет");
			//ДокументРезультат.Вывести(ОбластьИтогиСчет, 0);
			//ОбластьИтогиСтрокаЧисла = Макет.ПолучитьОбласть("ИтогиСтрока|Числа");
			//ОбластьИтогиЧисла       = Макет.ПолучитьОбласть("Итоги|Числа");
			//ОбластьИтогиСтрокаСчет  = Макет.ПолучитьОбласть("ИтогиСтрока|Счет");
			//НомерТекущейСтрокиИтога = 0;
			//ИтогиПодвал = Макет.ПолучитьОбласть("ИтогиПодвал");
			//ДокументРезультат.Вывести(ИтогиПодвал, 0);
			/*// Заполним общую расшифровку:
*/
			//СтруктураНастроекОтчета = ОбъектОтчета.СформироватьОбщуюСтруктуруДляРасшифровки();
			//СтруктураНастроекОтчета.Вставить("ПоказыватьЗаголовок", ПоказыватьЗаголовок);
			//ДокументРезультат.Область(1, 1).Расшифровка = СтруктураНастроекОтчета;
			/*// Зафиксируем заголовок отчета
*/
			//ДокументРезультат.ФиксацияСверху = ВысотаЗаголовка + 3;
			/*// Первую колонку не печатаем
*/
			//ДокументРезультат.ОбластьПечати = ДокументРезультат.Область(1, 2, ДокументРезультат.ВысотаТаблицы, ДокументРезультат.ШиринаТаблицы);
			/*// Выводится по ширине листа
*/
			//ДокументРезультат.Автомасштаб   = Истина;
			//УправлениеОтчетами.УстановитьКолонтитулыПоУмолчанию(ДокументРезультат, ОбъектОтчета.ЗаголовокОтчета(), Строка(ПараметрыСеанса.ТекущийПользователь));
		}
		// Заполняет параметры расшифровки переданной области перед выводом в отчет
		//
		// Параметры:
		//	Область - табличный документ, параметры расшифровки которого заполняются,
		//	Выборка - спозиционированная выборка из результата запроса,
		//	ОтборСубконто - параметр, содержащий таблицу отбора, которая будет использована
		//	при построении отчета по расшифровке.
		//

		public void ЗаполнитьПараметрыРасшифровкиОборотноСальдовойВедомости(/*Знач ДатаНач, Знач ДатаКон, Знач ИмяРегистраБухгалтерии,
	Область, Выборка, ОтборСубконто = Неопределено, ВыведенныйСчет = Неопределено, Знач ВВалютеСценария = Неопределено*/)
		{
			/*// Заполение значений для расшифровки
*/
			//СчетДляРасшифровки = ?(Выборка.Счет <> NULL, Выборка.Счет, ВыведенныйСчет);
			/*// Заполнение параметров расшифровки
*/
			//ПараметрыОСВПоСчету = Новый Соответствие;
			//ПараметрыОСВПоСчету.Вставить("ИмяОбъекта", "ОборотноСальдоваяВедомостьПоСчету" + ИмяРегистраБухгалтерии);
			//ПараметрыОСВПоСчету.Вставить("ЗаполнитьПоУмолчанию", Истина);
			//ПараметрыОСВПоСчету.Вставить("Счет", СчетДляРасшифровки);
			if(true/*ВВалютеСценария <> Неопределено*/)
			{
				//ПараметрыОСВПоСчету.Вставить("ВВалютеСценария", ВВалютеСценария);
			}
			//ПараметрыКарточкиСчета = Новый Соответствие;
			//ПараметрыКарточкиСчета.Вставить("ИмяОбъекта", "КарточкаСчета" + ИмяРегистраБухгалтерии);
			//ПараметрыКарточкиСчета.Вставить("Счет", СчетДляРасшифровки);
			//ПараметрыАнализСчета = Новый Соответствие;
			//ПараметрыАнализСчета.Вставить("ИмяОбъекта", "АнализСчета" + ИмяРегистраБухгалтерии);
			//ПараметрыАнализСчета.Вставить("ЗаполнитьПоУмолчанию", Истина);
			//ПараметрыАнализСчета.Вставить("Счет", СчетДляРасшифровки);
			if(true/*ВВалютеСценария <> Неопределено*/)
			{
				//ПараметрыАнализСчета.Вставить("ВВалютеСценария", ВВалютеСценария);
			}
			//ПараметрыОборотыСчетаМесяц = Новый Соответствие;
			//ПараметрыОборотыСчетаМесяц.Вставить("ИмяОбъекта", "ОборотыСчета" + ИмяРегистраБухгалтерии);
			//ПараметрыОборотыСчетаМесяц.Вставить("ЗаполнитьПоУмолчанию", Истина);
			//ПараметрыОборотыСчетаМесяц.Вставить("Счет", СчетДляРасшифровки);
			//ПараметрыОборотыСчетаМесяц.Вставить("Период", "МЕСЯЦ");
			//ПараметрыОборотыСчетаМесяц.Вставить("ВсеПериоды",  Истина);
			if(true/*ВВалютеСценария <> Неопределено*/)
			{
				//ПараметрыОборотыСчетаМесяц.Вставить("ВВалютеСценария", ВВалютеСценария);
			}
			//ПараметрыОборотыСчетаДень = Новый Соответствие;
			//ПараметрыОборотыСчетаДень.Вставить("ИмяОбъекта", "ОборотыСчета" + ИмяРегистраБухгалтерии);
			//ПараметрыОборотыСчетаДень.Вставить("ЗаполнитьПоУмолчанию", Истина);
			//ПараметрыОборотыСчетаДень.Вставить("Счет", СчетДляРасшифровки);
			//ПараметрыОборотыСчетаДень.Вставить("Период",  "ДЕНЬ");
			//ПараметрыОборотыСчетаДень.Вставить("ВсеПериоды",  Ложь);
			if(true/*ВВалютеСценария <> Неопределено*/)
			{
				//ПараметрыОборотыСчетаДень.Вставить("ВВалютеСценария", ВВалютеСценария);
			}
			//СписокРасшифровки = Новый СписокЗначений;
			//ИмяГруппировки = Выборка.Группировка();
			if(true/*Лев(ИмяГруппировки, СтрДлина(ИмяГруппировки) - 1) = "Субконто"*/)
			{
				if(true/*ОтборСубконто <> Неопределено*/)
				{
					//ОтборСубконто.Вставить(ИмяГруппировки, Выборка[ИмяГруппировки]);
					/*// Область должна содержать свою копию отбора по субконто
*/
					//ОтборРасшифровка = СоздатьКопиюСоответствияСтруктуры(ОтборСубконто);
					//ПараметрыКарточкиСчета.Вставить("Отбор", ОтборРасшифровка);
				}
				//СписокРасшифровки.Добавить(ПараметрыКарточкиСчета, "Карточка счета " + Выборка.СчетПредставление);
			}
			//Область.Параметры.Расшифровка = СписокРасшифровки;
		}
		// процедура дополняет основной отбор для отчета параметрами из дополнительного отбора

		public void ДополнитьОтборОтчетаДополнительнымиПараметрами(/*ОсновнойОтбор, ДопРасшифровка*/)
		{
			if(true/*ДопРасшифровка = Неопределено
		ИЛИ ОсновнойОтбор = Неопределено*/)
			{
			}
			if(true/*ТипЗнч(ДопРасшифровка) = Тип("ТаблицаЗначений")*/)
			{
			}
		}
		//Процедура копирует параметры расшифровки из одной структуры в другию

		public void СкопироватьОбщиеПараметрыРасшифровки(/*Знач ОбщаяРасшифровка, Знач ВыбраннаяРасшифровка*/)
		{
			if(true/*ТипЗнч(ОбщаяРасшифровка) = Тип("Структура") 
		ИЛИ ТипЗнч(ОбщаяРасшифровка) = Тип("Соответствие")*/)
			{
			}
		}
		//Процедура дополнить дополнительными отборами пареметры расшифровки отчета

		public void ДополнитьДопОтборамиРасшифровкуДанных(/*ВыбраннаяРасшифровка*/)
		{
			if(true/*ТипЗнч(ВыбраннаяРасшифровка) = Тип("Структура")*/)
			{
				//ОтборыДанных = Неопределено;
				//ВыбраннаяРасшифровка.Свойство("Отбор", ОтборыДанных);
				//ДопОтборыДанных = Неопределено;
				//ВыбраннаяРасшифровка.Свойство("ДополнительныеОтборы", ДопОтборыДанных);
			}
			/*// дополнительная расшифровка
*/
			//ДополнитьОтборОтчетаДополнительнымиПараметрами(ОтборыДанных, ДопОтборыДанных);
		}
		// процедура выводит расшифровку оборотно сальдовой ведомости

		public void ДокументРезультатОбработкаРасшифровкиОборотноСальдовойВедомости(/*Элемент, Расшифровка, 
		СтандартнаяОбработка, Знач ПоказыватьЗаголовок*/)
		{
			if(true/*ТипЗнч(Расшифровка) = Тип("СписокЗначений")*/)
			{
				if(true/*Расшифровка.Количество() = 1*/)
				{
					//ВыбранноеЗначение = Расшифровка[0];
				}
				if(true/*ВыбранноеЗначение <> Неопределено*/)
				{
					//ВыбраннаяРасшифровка = ВыбранноеЗначение.Значение;
				}
			}
			if(true/*ТипЗнч(ВыбраннаяРасшифровка) = Тип("Структура") 
		ИЛИ ТипЗнч(ВыбраннаяРасшифровка) = Тип("Соответствие")*/)
			{
				/*// Добавим общую расшифровку из левого верхнего угла
*/
				//ОбщаяРасшифровка = Элемент.Область(1, 1).Расшифровка;
				//СкопироватьОбщиеПараметрыРасшифровки(ОбщаяРасшифровка, ВыбраннаяРасшифровка);
				//ДополнитьДопОтборамиРасшифровкуДанных(ВыбраннаяРасшифровка);
				//СтандартнаяОбработка = Ложь;
				//Отчет = Отчеты[ВыбраннаяРасшифровка["ИмяОбъекта"]].Создать();
				//Отчет.Настроить(ВыбраннаяРасшифровка);
				//ФормаОтчета = Отчет.ПолучитьФорму(, , Новый УникальныйИдентификатор());
				//ФормаОтчета.ПоказыватьЗаголовок = ПоказыватьЗаголовок;
				//ФормаОтчета.ОбновитьОтчет();
				//ФормаОтчета.Открыть();
			}
		}
		///////////////////////////////////////////////////////////////////////////////
		//КАРТОЧКА СЧЕТА
		///////////////////////////////////////////////////////////////////////////////
		// процедура устанавливает отборы посторителя по субконто счета

		public void УстановитьЗапросИОтборПостроителяПоСубконтоДляДвижений(/*Знач Счет, Знач ИмяРегистраБухгалтерии, Знач ПостроительОтчета,
	Знач ДополнительныеОтборы = ""*/)
		{
			while(true/*ПостроительОтчета.Отбор.Количество() > 0*/)
			{
				//ПостроительОтчета.Отбор.Удалить(0);
			}
			/*;
		
	ТекстСубконто = "";*/
			/*// Если есть субконто, настроим отбор по субконто
*/
			//СтруктураСубконто = Новый Структура;
			if(true/*Не ПустаяСтрока(ДополнительныеОтборы)*/)
			{
				//ТекстСубконто = ТекстСубконто + ", " + ДополнительныеОтборы;
			}
			if(true/*Не ПустаяСтрока(ТекстСубконто)*/)
			{
				//СтрокаОграниченийДляПостроителя = "{" + Сред(ТекстСубконто, 3) + "}";
			}
			/*ПостроительОтчета.Текст = "
		|ВЫБРАТЬ РАЗРЕШЕННЫЕ 1 
		|ИЗ РегистрБухгалтерии." + ИмяРегистраБухгалтерии + ".ДвиженияССубконто(,," + СтрокаОграниченийДляПостроителя + ")";*/
		}
		// Функция возвращает представление периода строкой
		//
		// Параметры:
		//  ДатаПериода - Дата в интревале опредеяемого периода
		//
		// Возвращаемое значение:
		//  Строковое представление интервала
		//

		public object ПолучитьПериодДатСтрокой(/*Знач Период, Знач ДатаПериода*/)
		{
			//ПериодСтр = Период;
			if(true/*ПериодСтр = "ДЕНЬ"*/)
			{
				//ДатаНачала    = НачалоДня(ДатаПериода);
				//ДатаОкончания = КонецДня(ДатаПериода);
			}
			//Возврат ПредставлениеПериода(ДатаНачала, ДатаОкончания, "ФП=Истина");
			return null;
		}
		//Функция получает конечную дату по дате и периоду

		public object ПолучитьДатуОкончанияПериода(/*Знач ДатаОграничений, Знач Период*/)
		{
			if(true/*ДатаОграничений = Null
		ИЛИ ДатаОграничений = Неопределено*/)
			{
			}
			//ПериодПо = ДатаОграничений;
			if(true/*Период = "ДЕНЬ"*/)
			{
				//ПериодПо = ДатаОграничений + 24 * 60 * 60 - 1;
			}
			return null;
		}
		//Процедура устанавливает параметры ограничения запросу из строки ограничений построителя отчета

		public void УстановитьПараметрыЗапросаПоСтрокеПостроителяОтчета(/*Запрос, Знач СтрокаОтбора, Знач ПостфиксОграничения*/)
		{
			//СтрокаПостфикса = Строка(ПостфиксОграничения);
			if(true/*СтрокаОтбора.ВидСравнения = ВидСравнения.Содержит
		ИЛИ СтрокаОтбора.ВидСравнения = ВидСравнения.НеСодержит*/)
			{
				/*// ограничение на содержит отрабатывается отдельным образом
*/
				/*// надо из значения ограничения лишние символы преобразовать и дополнить ограничение символами %%
*/
				//ИтоговаяСтрокаОграничения = ОбщегоНазначения.СформироватьСтрокуДляПоискаВЗапросе(СтрокаОтбора.Значение);
				//ИтоговаяСтрокаОграничения = "%" + ИтоговаяСтрокаОграничения + "%";
				//Запрос.УстановитьПараметр("Значение" + СтрокаПостфикса, ИтоговаяСтрокаОграничения);
			}
		}
		//Функция формирует строку ограничений для запроса по ограничениям построителя отчетов

		public object ПолучитьТекстОграниченийПоПостроителюОтчета(/*ПостроительОтчета, Запрос*/)
		{
			//ТекстФильтры = "";
			//Индекс = 0;
			return null;
		}
		// процедура выводит данные остатков по оборотам в макет

		public void ВывестиДанныеОстатковКарточкиСчетаВМакет(/*ЗапросПоОстаткам, Знач ОбластьМакет, Знач Счет, Знач ЗапросНаНачало, 
	ТекущееСальдо = 0, ТекущееСальдоКолво = 0*/)
		{
			//Остатки = ЗапросПоОстаткам.Выполнить().Выбрать();
			//Остатки.Следующий();
			if(true/*ЗапросНаНачало*/)
			{
				//ОбластьМакет.Параметры.ОписательСальдо = "Сальдо на начало";
				//ВыводитьИтогПоКоличеству = Счет.Количественный;
			}
			//СуммаОстатокДт = ПривестиКЧислу(Остатки.СуммаОстатокДт);
			//СуммаОстатокКт = ПривестиКЧислу(Остатки.СуммаОстатокКт);
			//КоличествоОстатокДт = ПривестиКЧислу(Остатки.КоличествоОстатокДт);
			//КоличествоОстатокКт = ПривестиКЧислу(Остатки.КоличествоОстатокКт);
			//ТекущееСальдо = СуммаОстатокДт - СуммаОстатокКт;
			//ТекущееСальдоКолво = КоличествоОстатокДт - КоличествоОстатокКт;
			if(true/*Счет.Вид = ВидСчета.АктивноПассивный*/)
			{
				if(true/*СуммаОстатокДт > СуммаОстатокКт*/)
				{
					//ОбластьМакет.Параметры.СуммаСальдоДт   = ТекущееСальдо;
					//ОбластьМакет.Параметры.СуммаСальдоКт   = 0;
					if(true/*ВыводитьИтогПоКоличеству*/)
					{
						//ОбластьМакет.Параметры.КоличествоСальдоДт   = ТекущееСальдоКолво;
						//ОбластьМакет.Параметры.КоличествоСальдоКт   = 0;
					}
				}
			}
		}
		// Проверка соответствия половины проводки установленным отборам пользователя
		//
		// Параметры
		//  Выборка  – ВыборкаИзРезультатаЗапроса – Выборка из результата запроса
		//  Сторона  – Строка                     – Дт/Кт
		//
		// Возвращаемое значение:
		//   Булево   – Соответствует или нет сторона проводки установленным отборам
		//

		public object ЗначениеПоляСоответствуетОтбору(/*Выборка, Знач СторонаПроводки, ПостроительОтчета*/)
		{
			//Результат = Истина;
			return null;
		}
		// СоответствуетОтбору()

		public object ВИерархии(/*ЛевоеЗначение, ПравоеЗначение*/)
		{
			if(true/*ТипЗнч(ЛевоеЗначение) <> ТипЗнч(ПравоеЗначение)*/)
			{
			}
			return null;
		}
		///////////////////////////////////////////////////////////////////////////////
		//ОБОРОТЫ СЧЕТА
		///////////////////////////////////////////////////////////////////////////////
		// процедура обрабатывает выбор для строки отборов

		public void ОбработатьВыборДляСтрокиОтбораБухОтчетов(/*СтрокаОтбора, Элемент, СтандартнаяОбработка, ОбъектОтчет*/)
		{
			if(true/*СтрокаОтбора = Неопределено*/)
			{
			}
			/*// Принятая в конфигурации обработка работает только для равенства/неравенства
*/
			if(true/*СтрокаОтбора.ВидСравнения = ВидСравнения.Равно
	 ИЛИ СтрокаОтбора.ВидСравнения = ВидСравнения.НеРавно*/)
			{
				//ТипЗначенияПоля = СтрокаОтбора.ТипЗначения;
				//ОбъектОтчет.НачалоВыбораЗначенияСубконто(Элемент, СтандартнаяОбработка, ТипЗначенияПоля);
			}
		}
		// функция приводит значение из выборки к числу

		public object ПривестиКЧислу(/*Значение*/)
		{
			if(true/*Значение = NULL*/)
			{
			}
			return null;
		}
		//функция удаляет при необходимости область из макета

		public object УдалитьОбластьИзмакетаПриНеобходимости(/*Макет, Знач ИмяОбласти, Знач НужноУдалятьОбласть*/)
		{
			if(true/*НЕ НужноУдалятьОбласть*/)
			{
				//Макет.УдалитьОбласть(Макет.Область(ИмяОбласти), ТипСмещенияТабличногоДокумента.ПоГоризонтали);
			}
			return null;
		}
		//Функция возвращает строку формата периода

		public object ПолучитьСтрокуФорматаПериода(/*Знач Период*/)
		{
			//ФорматПериода = "";
			if(true/*ЗначениеЗаполнено(Период)*/)
			{
				if(true/*Врег(Период) = "ГОД"*/)
				{
					//ФорматПериода = "ДФ = ""гггг """"г.""""""";
				}
			}
			return null;
		}

		public void ВывестиЗаголовкиОборотовОтчетаОборотыСчета(/*Макет, Знач ИмяОбластиВывода, Знач Выборка, 
	Знач ДокументРезультат, Знач ПоСубсчетам, Знач ВидДвижения, МассивРесурсов, СписокСчетов, Знач ДополнениеКУровнюВывода = 0*/)
		{
			//ВерхнийУровень = 1000;
			//Обл = Макет.ПолучитьОбласть(ИмяОбластиВывода);
			while(true/*Выборка.Следующий()*/)
			{
				if(true/*НЕ ПоСубсчетам*/)
				{
					/*// Выводим только верхний уровень
*/
					if(true/*ВерхнийУровень < Выборка.Уровень()*/)
					{
					}
				}
				//ЕстьОборот = Ложь;
				//ОкончанниеПоля = ?(ВидДвижения = ВидДвиженияБухгалтерии.Дебет, "Дт", "Кт");
				if(true/*ЕстьОборот*/)
				{
					//СписокСчетов.Добавить(Выборка.КорСчет);
					//Обл.Параметры.Заполнить(Выборка);
					//ДокументРезультат.Присоединить(Обл, Выборка.Уровень() + ДополнениеКУровнюВывода);
				}
			}
			//;;
		}
		//Процедура возвращает суммы на начало периода

		public void ПолучитьДанныеДляОборотов(/*ДанныеДляВыбораСумм, ПостфиксИменПолей, 
	Знач ПолучатьКоличество, Знач ПолучатьВалюту, СуммаДт, СуммаКт, КоличествоДт = Неопределено, 
	КоличествоКт = Неопределено, ВалютнаяСуммаДт = Неопределено, ВалютнаяСуммаКт = Неопределено*/)
		{
			//СуммаДт = ПривестиКЧислу(ДанныеДляВыбораСумм["Сумма" + ПостфиксИменПолей + "Дт"]);
			//СуммаКт = ПривестиКЧислу(ДанныеДляВыбораСумм["Сумма" + ПостфиксИменПолей + "Кт"]);
			if(true/*ПолучатьКоличество*/)
			{
				//КоличествоДт = ПривестиКЧислу(ДанныеДляВыбораСумм["Количество" + ПостфиксИменПолей + "Дт"]);
				//КоличествоКт = ПривестиКЧислу(ДанныеДляВыбораСумм["Количество" + ПостфиксИменПолей + "Кт"]);
			}
			if(true/*ПолучатьВалюту*/)
			{
				//ВалютнаяСуммаДт = ПривестиКЧислу(ДанныеДляВыбораСумм["ВалютнаяСумма" + ПостфиксИменПолей + "Дт"]);
				//ВалютнаяСуммаКт = ПривестиКЧислу(ДанныеДляВыбораСумм["ВалютнаяСумма" + ПостфиксИменПолей + "Кт"]);
			}
		}
		//Функция определяет по построителю отчета и имени субконто вести про нему количественный учет или нет

		public object ОпределитьПоСубконтоИПостроителюВестиКоличественныйУчет(/*Счет, ПостроительОтчета, Знач Измерение*/)
		{
			if(true/*Врег(Измерение) = "СЧЕТ"*/)
			{
			}
			//ИзмерениеПостроителя = ПостроительОтчета.ИзмеренияСтроки.Найти(Измерение);
			if(true/*ИзмерениеПостроителя <> Неопределено*/)
			{
				//ИмяПоля = ИзмерениеПостроителя.ПутьКДанным;
				//поз = Найти(ИмяПоля, ".");
				//ИмяПоля = ?(поз=0, ИмяПоля, Лев(ИмяПоля, поз-1));
			}
			//ВыводКоличества = Счет.ВидыСубконто[ИндСубконто - 1].Количественный;
			return null;
		}
		// процедура выполняет заполнение отчета обороты счета параметрами

		public void ЗаполнитьСуммыОборотаСчета(/*Знач ДокументРезультат, Знач ВыводитьКоличество, Знач Уровень, Знач ОбластьВывода, Знач ИмяПараметраСуммы, Знач ИмяПараметраКоличества,
	Знач Сумма, Знач Количество*/)
		{
			//ОбластьВывода.Параметры[ИмяПараметраСуммы] = Сумма;
			if(true/*ВыводитьКоличество*/)
			{
				//ОбластьВывода.Параметры[ИмяПараметраКоличества] = Количество;
			}
			//ДокументРезультат.Присоединить(ОбластьВывода, Уровень);
		}
		// процедура выводит заголовок для отчета обороты счета

		public void ВывестиПолныйЗаголовокОтчетаОборотовСчета(/*Выборка = Неопределено, ШиринаТаблицы, ОбъектОтчет, Макет, ДокументРезультат,
	РезультатЗапроса, Знач ИмяСтроки, МассивРесурсов, СписокДт, СписокКт, Знач ДополнениеКУровнюВывода = 0, Знач ВыборкаИтогов = Неопределено, 
	Знач ОбщийИтог = Неопределено*/)
		{
			/*// Вывод заголовков нач.сальдо
*/
			if(true/*ОбъектОтчет.СальдоНачДт*/)
			{
				//ОблСальдоНачДт = Макет.ПолучитьОбласть(ИмяСтроки+"|СальдоНачДт");
				if(true/*ВыборкаИтогов <> Неопределено*/)
				{
					//ОблСальдоНачДт.Параметры.Заполнить(ВыборкаИтогов);
				}
				//ДокументРезультат.Присоединить(ОблСальдоНачДт, 0);
				//ШиринаТаблицы = ШиринаТаблицы + ОблСальдоНачДт.ШиринаТаблицы;
			}
			if(true/*ОбъектОтчет.СальдоНачКт*/)
			{
				//ОблСальдоНачКт = Макет.ПолучитьОбласть(ИмяСтроки+"|СальдоНачКт");
				if(true/*ВыборкаИтогов <> Неопределено*/)
				{
					//ОблСальдоНачКт.Параметры.Заполнить(ВыборкаИтогов);
				}
				//ДокументРезультат.Присоединить(ОблСальдоНачКт, 0);
				//ШиринаТаблицы = ШиринаТаблицы + ОблСальдоНачКт.ШиринаТаблицы;
			}
			/*// Вывод заголовков оборотов
*/
			if(true/*ОбъектОтчет.ОборотДт*/)
			{
				//ОблОборотДт = Макет.ПолучитьОбласть(ИмяСтроки+"|ОборотДт");
				if(true/*ОбщийИтог <> Неопределено*/)
				{
					//ОблОборотДт.Параметры.Заполнить(ОбщийИтог);
				}
				//ДокументРезультат.Присоединить(ОблОборотДт, 0);
				//ШиринаТаблицы = ШиринаТаблицы + ОблОборотДт.ШиринаТаблицы;
			}
			/*// Вывод кор счетов с дебетовыми оборотами
*/
			if(true/*Выборка = Неопределено*/)
			{
				//Выборка = РезультатЗапроса.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам, "КорСчет", "Все");
			}
			/*// вывод заголовков для корреспондирующих счетов
*/
			//СписокДт = Новый СписокЗначений;
			if(true/*ОбъектОтчет.ОборотДтКорСчета*/)
			{
				/*ВывестиЗаголовкиОборотовОтчетаОборотыСчета(Макет, ИмяСтроки+"|ОборотДтКорсчет", Выборка,
			ДокументРезультат, ОбъектОтчет.ПоСубсчетамКорСчетов, ВидДвиженияБухгалтерии.Дебет, МассивРесурсов, СписокДт, ДополнениеКУровнюВывода);*/
			}
			/*// вывод данных по кредитовому обороту
*/
			if(true/*ОбъектОтчет.ОборотКт*/)
			{
				//ОблОборотКт = Макет.ПолучитьОбласть(ИмяСтроки+"|ОборотКт");
				if(true/*ОбщийИтог <> Неопределено*/)
				{
					//ОблОборотКт.Параметры.Заполнить(ОбщийИтог);
				}
				//ДокументРезультат.Присоединить(ОблОборотКт, 0);
				//ШиринаТаблицы = ШиринаТаблицы + ОблОборотКт.ШиринаТаблицы;
			}
			/*// Вывод кор счетов с кредитовыми оборотами
*/
			//СписокКт = Новый СписокЗначений;
			//Выборка.Сбросить();
			if(true/*ОбъектОтчет.ОборотКтКорСчета*/)
			{
				/*ВывестиЗаголовкиОборотовОтчетаОборотыСчета(Макет, ИмяСтроки+"|ОборотКтКорсчет", Выборка, 
			ДокументРезультат, ОбъектОтчет.ПоСубсчетамКорСчетов, ВидДвиженияБухгалтерии.Кредит, МассивРесурсов, СписокКт, ДополнениеКУровнюВывода);*/
			}
			if(true/*ДополнениеКУровнюВывода <> 0*/)
			{
				if(true/*ОбъектОтчет.СальдоКонДт*/)
				{
					//ОблСальдоКонДт = Макет.ПолучитьОбласть(ИмяСтроки+"|СальдоКонДт");
					//ДокументРезультат.Присоединить(ОблСальдоКонДт,0);
					//ШиринаТаблицы = ШиринаТаблицы + ОблСальдоКонДт.ШиринаТаблицы;
				}
				if(true/*ОбъектОтчет.СальдоКонКт*/)
				{
					//ОблСальдоКонКт = Макет.ПолучитьОбласть(ИмяСтроки+"|СальдоКонКт");
					//ДокументРезультат.Присоединить(ОблСальдоКонКт,0);
					//ШиринаТаблицы = ШиринаТаблицы + ОблСальдоКонКт.ШиринаТаблицы;
				}
			}
		}
		// процедурв выводит итоги оборотов за период для отчета обороты счета

		public void ВывестиОборотыЗаПериод(/*СчетОграниченийОтчета, Знач ЕстьИтог, ОбщийИтог, Макет, ДокументРезультат,
	Знач СальдоКонДт, Знач СальдоКонКт*/)
		{
			//СуммаКонКт = 0;
			//СуммаКонДт = 0;
			if(true/*ЕстьИтог*/)
			{
				//СуммаНачКт = 0;
				//СуммаНачДт = 0;
				//СуммаОборотКт = 0;
				//СуммаОборотДт = 0;
				/*ПолучитьДанныеДляОборотов(ОбщийИтог, "Нач",
			Ложь, Ложь, СуммаНачДт, СуммаНачКт);*/
				/*ПолучитьДанныеДляОборотов(ОбщийИтог, "Кон",
			Ложь, Ложь, СуммаКонДт, СуммаКонКт);*/
				/*ПолучитьДанныеДляОборотов(ОбщийИтог, "Оборот", 
			Ложь, Ложь, СуммаОборотДт, СуммаОборотКт);*/
			}
			if(true/*СальдоКонДт*/)
			{
				//Обл=Макет.ПолучитьОбласть("Итог|СальдоКонДт");
				//Обл.Параметры.СуммаКонДт=СуммаКонДт;
				//ДокументРезультат.Присоединить(Обл);
			}
			if(true/*СальдоКонКт*/)
			{
				//Обл=Макет.ПолучитьОбласть("Итог|СальдоКонКт");
				//Обл.Параметры.СуммаКонКт=СуммаКонКт;
				//ДокументРезультат.Присоединить(Обл);
			}
		}
		// процедура поддержка одновирменности для БухОтчетов

		public void ПоддержкаОднофирменностиДляБухОтчетов(/*Форма, Организация, УчетПоВсемОрганизациям, Знач ЗаполнятьОрганизацию = Истина*/)
		{
			if(true/*ЗаполнятьОрганизацию ИЛИ НЕ УчетПоВсемОрганизациям*/)
			{
				//ПроизвестиПроверкуНаВедениеОднофирменности(Организация);
			}
			//Форма.ЭлементыФормы.Организация.ТолькоПросмотр = НЕ УчетПоВсемОрганизациям;
		}
		// процедура поддержка одновирменности для формы настроек БухОтчетов

		public void ПоддержкаОднофирменностиДляФормыНастроекБухОтчетов(/*Форма, УчетПоВсемОрганизациям*/)
		{
			//Форма.ЭлементыФормы.Организация.ТолькоПросмотр = НЕ УчетПоВсемОрганизациям;
		}
		///////////////////////////////////////////////////////////////////////////////
		//ОБОРОТЫ ПО СЧЕТУ
		///////////////////////////////////////////////////////////////////////////////
		// процедура выводит итоги отчета оборотно сальдовая ведомость по счету

		public void ВывестиИтогиОборотноСальдовойВедомостиПоСчету(/*Знач Выборка, Знач ИмяРегистраБухгалтерии, Знач МассивПоказателей, Знач ФорматПоказателей,
	Знач Счет, Знач ОбластьИтогиСтрокаЧисла, Знач ОбластьИтогиЧислаМакет, Знач ОбластьИтогиСтрокаСчет, Знач ДокументРезультат, ВыводитьРазвернутоеСальдо = Ложь*/)
		{
			//ЭтоПерваяСтрока = Ложь;
		}
		// процедура выводит текущие показатели оборотно сальдовой ведомости по счету

		public void ВывестиПоказателиОборотноСальдовойВедомостиПоСчету(/*Выборка, СтруктураПараметров, Знач Счет, 
	Знач СтруктураЗамещающихДанных = Неопределено*/)
		{
			//ВыведеноПоказателей = 0;
			/*// количество выведенных показателей
*/
		}
		//процедура выводит вложенную группировку оборотно сальдовой ведомости оп счету

		public void ВывестиВложеннуюГруппировкуОборотноСальдовойВедомостиПоСчету(/*ОбъектОтчета, Выборка, Знач ИндексТекущейГруппировки, 
	СтруктураПараметров*/)
		{
			if(true/*ИндексТекущейГруппировки + 1 >= СтруктураПараметров.МассивГруппировок.Количество()*/)
			{
			}
			/*ВывестиГруппировкуОборотноСальдовойВедомостиПоСчету(ОбъектОтчета, Выборка.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам, СтруктураПараметров.МассивГруппировок[ИндексТекущейГруппировки + 1]), 
		ИндексТекущейГруппировки + 1, СтруктураПараметров);*/
		}
		// Выводит группировку при развороте счета по субсчетам и/или субконто для оборотно сальдовой ведомости по счету

		public void ВывестиГруппировкуОборотноСальдовойВедомостиПоСчету(/*ОбъектОтчета, Выборка, Знач ИндексТекущейГруппировки, СтруктураПараметров*/)
		{
			while(true/*Выборка.Следующий()*/)
			{
				//ИмяГруппировки = Выборка.Группировка();
				if(true/*ИмяГруппировки = "Счет"*/)
				{
					//ВыводимаяОбласть = СтруктураПараметров.ОбластьСтрокаСчет;
					//ВыводимаяОбласть.Параметры.Заполнить(Выборка);
					//ЗаполнитьПараметрыРасшифровкиОбороткиПоСчету(ОбъектОтчета, ВыводимаяОбласть, Выборка, СтруктураПараметров);
				}
				/*// При выводе субсчетов не делаем отступы
*/
				//Отступ = ОбщегоНазначения.ВернутьИндексВМассиве(СтруктураПараметров.МассивГруппировок, ИмяГруппировки);
				/*// Не выводим счета более высокого уровня
*/
				if(true/*ИмяГруппировки = "Счет" 
			И СтруктураПараметров.СоответствиеСчетовПредков[Выборка.Счет] <> Неопределено*/)
				{
					//ВывестиВложеннуюГруппировкуОборотноСальдовойВедомостиПоСчету(ОбъектОтчета, Выборка, ИндексТекущейГруппировки, СтруктураПараметров);
				}
				//ДокументРезультат = СтруктураПараметров.ДокументРезультат;
				//ВыводимаяОбласть.Область("R1C2").Отступ = Отступ;
				//ДокументРезультат.Вывести(ВыводимаяОбласть, Выборка.Уровень() );
				if(true/*Выборка.ТипЗаписи() = ТипЗаписиЗапроса.ИтогПоИерархии 
		   И ИмяГруппировки <> "Счет"*/)
				{
					//ДокументРезультат.Область(ДокументРезультат.ВысотаТаблицы, 2).Шрифт = СтруктураПараметров.ШрифтГрупп;
				}
				//ВывестиПоказателиОборотноСальдовойВедомостиПоСчету(Выборка, СтруктураПараметров, ОбъектОтчета.Счет);
				/*// Если по валютам,
*/
				if(true/*СтруктураПараметров.СтруктураОграничений.ПоВалютам*/)
				{
					//ВыборкаПоВалютам = Выборка.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам, "Валюта");
					while(true/*ВыборкаПоВалютам.Следующий()*/)
					{
						//ВыводимаяОбласть = СтруктураПараметров.ОбластьСтрокаПоказателяСчет;
						//ВыводимаяОбласть.Параметры.Заполнить(Выборка);
						//ВыводимаяОбласть.Параметры.СубконтоПредставление = "Валюта " + ВыборкаПоВалютам.ВалютаПредставление;
						//ВыводимаяОбласть.Область("R1C2").Отступ = Отступ + 1;
						/*// Заполнение параметров расшифровки
*/
						//ЗаполнитьПараметрыРасшифровкиОбороткиПоСчету(ОбъектОтчета, ВыводимаяОбласть, Выборка, СтруктураПараметров);
						//ДокументРезультат.Вывести(ВыводимаяОбласть, Выборка.Уровень());
						//ВывестиПоказателиОборотноСальдовойВедомостиПоСчету(ВыборкаПоВалютам, СтруктураПараметров, ОбъектОтчета.Счет);
					}
					//;;
				}
				/*// Если есть следующая группировка, то выбираем ее
*/
				//ВывестиВложеннуюГруппировкуОборотноСальдовойВедомостиПоСчету(ОбъектОтчета, Выборка, ИндексТекущейГруппировки, СтруктураПараметров);
			}
			//;;
		}
		//Функция формирует структуру параметров ограничений для оборотно-сальдовой ведомости

		public object СформироватьСтруктуруОграниченийДляОборотноСальдовойВедомостиПоСчету(/*ОбъектОтчета,
		Знач ПоВалютам, Знач ВидУчета = Неопределено, Знач Валюта = Неопределено, Знач ОтражениеВНУ = Неопределено,
		Знач Сценарий = Неопределено, Знач ВВалютеСценария = Неопределено*/)
		{
			//Структура = Новый Структура();
			//Структура.Вставить("ДатаНач", ОбъектОтчета.ДатаНач);
			//Структура.Вставить("ДатаКон", ОбъектОтчета.ДатаКон);
			//Структура.Вставить("ПоВалютам", ПоВалютам);
			//Структура.Вставить("ВидУчета", ВидУчета);
			//Структура.Вставить("Валюта",  Валюта);
			//Структура.Вставить("ОтражениеВНУ",  ОтражениеВНУ);
			//Структура.Вставить("Сценарий",  Сценарий);
			//Структура.Вставить("ВВалютеСценария",  ВВалютеСценария);
			//Структура.Вставить("ИмяРегистраБухгалтерии", ОбъектОтчета.ИмяРегистраБухгалтерии);
			return null;
		}
		//Функция Определяет вид отбора по типу значения объекта

		public object ПолучитьВидОтбораПоТипуЗначения(/*ЗначениеОтбора*/)
		{
			//ВидСравненияОтчета = ВидСравнения.Равно;
			if(true/*(ЗначениеОтбора = NULL)	
		ИЛИ НЕ ЗначениеЗаполнено(ЗначениеОтбора)*/)
			{
			}
			/*// нужно определить это ссылочный тип или нет
*/
			return null;
		}
		//Функция создает структуру дополнительных ограничений для расшифровки отчета

		public object СоздатьСтруктуруДопОграниченийДляОборотноСальдовойВедомостиПоСчету(/*ОтчетОбъект, Выборка, МассивГруппировок, 
	Знач ВыводитьВсеГруппировки = Ложь*/)
		{
			//ДополнительныеОтборы = СоздатьТаблицуДляХраненияОтбора(Истина);
			//ИмяГруппировки = Выборка.Группировка();
			if(true/*ВыводитьВсеГруппировки*/)
			{
				//НомерГруппировкиВМассиве = МассивГруппировок.Количество() - 1;
			}
			return null;
		}
		// процедура заполняет параметры расшифровки для счета по отчету оборотно сальдовая ведомость по счету

		public void ЗаполнитьРасшифровкуДляСчета(/*ОтчетОбъект, Область, Выборка, СтруктураПараметров, Знач ИмяРегистраБухгалтерии,
	Знач РасшифровываемыйСчет, Знач РасшифровываемыйСчетПредставление*/)
		{
			//ПараметрыКарточкиСчета = Новый Соответствие;
			//ПараметрыКарточкиСчета.Вставить("ИмяОбъекта", "КарточкаСчета" + ИмяРегистраБухгалтерии);
			//ПараметрыКарточкиСчета.Вставить("Счет", РасшифровываемыйСчет);
			//ИмяГруппировки = Выборка.Группировка();
			if(true/*Лев(ИмяГруппировки, 8) = "Субконто"*/)
			{
				/*// надо в структуру доп ограничений поместить все группировки более высокого уровня
*/
				//ДополнительныеОтборы = СоздатьСтруктуруДопОграниченийДляОборотноСальдовойВедомостиПоСчету(ОтчетОбъект, Выборка, СтруктураПараметров.МассивГруппировок);
				//ПараметрыКарточкиСчета.Вставить("ДополнительныеОтборы", ДополнительныеОтборы);
				//СписокРасшифровки = Новый СписокЗначений;
				//СписокРасшифровки.Добавить(ПараметрыКарточкиСчета, "Карточка счета " + РасшифровываемыйСчетПредставление);
			}
			//Область.Параметры.Расшифровка = СписокРасшифровки;
		}
		// Заполняет параметры расшифровки
		//
		// Параметры:
		//	Нет.
		//

		public void ЗаполнитьПараметрыРасшифровкиОбороткиПоСчету(/*ОтчетОбъект, Область, Выборка, СтруктураПараметров*/)
		{
			/*// Если итоги по счету не анализируются, берем общий
*/
			if(true/*Выборка.Счет = NULL*/)
			{
				//РасшифровываемыйСчет = ОтчетОбъект.Счет;
				//РасшифровываемыйСчетПредставление = Строка(ОтчетОбъект.Счет);
			}
			/*ЗаполнитьРасшифровкуДляСчета(ОтчетОбъект, Область, Выборка, СтруктураПараметров, ОтчетОбъект.ИмяРегистраБухгалтерии,
		РасшифровываемыйСчет, РасшифровываемыйСчетПредставление);*/
		}
		///////////////////////////////////////////////////////////////////////////////
		//ОТЧЕТ ПО ПРОВОДКАМ
		///////////////////////////////////////////////////////////////////////////////
		// Формирование строки описания корреспонденций для заголовка отчета

		public object СформироватьОписаниеКорреспондеции(/*Корреспонденции*/)
		{
			//СтрокаОписания = "";
			return null;
		}

		public void ОбвестиОбластиОтчета(/*ДокументРезультат, НачалоСекции = 0, Линия, ЛинияЖирная*/)
		{
			//КонСтр = ДокументРезультат.ВысотаТаблицы;
			//ДокументРезультат.Область(КонСтр,2,КонСтр,4).ГраницаСнизу = Линия;
			//ДокументРезультат.Область(КонСтр,5,КонСтр,8).ГраницаСнизу = ЛинияЖирная;
			//ДокументРезультат.Область(КонСтр,9,КонСтр,12).ГраницаСнизу = Линия;
			//ДокументРезультат.Область(НачалоСекции,2,КонСтр,2).Объединить();
			//ДокументРезультат.Область(НачалоСекции,3,КонСтр,3).Объединить();
			//ДокументРезультат.Область(НачалоСекции,2,КонСтр,3).РазмещениеТекста = ТипРазмещенияТекстаТабличногоДокумента.Переносить;
		}
		// процедура создает колонки для корреспонденции плана счетов

		public void СоздатьКолонкиОграниченийДляКорреспонденцииПланаСчетов(/*Корреспонденции, Знач ИмяПланаСчетов*/)
		{
			//ОписаниеТиповПланСчетов = Новый ОписаниеТипов("ПланСчетовСсылка." + ИмяПланаСчетов);
			//ОписаниеТиповТаблицаЗначений = Новый ОписаниеТипов("ТаблицаЗначений");
			//ОписаниеТиповСтрока = Новый ОписаниеТипов("Строка",, Новый КвалификаторыСтроки(200));
			//Корреспонденции.Колонки.Добавить("СчетДт",     ОписаниеТиповПланСчетов, "Дебет");
			//Корреспонденции.Колонки.Добавить("СчетКт",     ОписаниеТиповПланСчетов, "Кредит");
			//Корреспонденции.Колонки.Добавить("Субконто",   ОписаниеТиповТаблицаЗначений);
			//Корреспонденции.Колонки.Добавить("ПредставлениеСубконто", ОписаниеТиповСтрока);
		}
		// Формирование списка номеров журналов, присутствующих в базе
		//
		// Параметры
		//    Нет
		//
		// Возвращаемое значение:
		//   СписокЗначений   – Список номеров журналов, которые есть в базе
		//

		public object ВернутьСписокНомеровЖурналов(/*Знач ИмяРегистраБухгалтерии*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст = 
	"ВЫБРАТЬ РАЗЛИЧНЫЕ
	|	Регистр.НомерЖурнала КАК НомерЖурнала
	|ИЗ
	|	РегистрБухгалтерии." + ИмяРегистраБухгалтерии + " КАК Регистр
	|
	|УПОРЯДОЧИТЬ ПО
	|	НомерЖурнала";*/
			//СписокНомеровЖурналов = Новый СписокЗначений;
			//СписокНомеровЖурналов.ЗагрузитьЗначения(Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("НомерЖурнала"));
			return null;
		}
		//Функция возвращает нужно ли пропустить текущую строку выборки при выводе данных или нет

		public object ОпределитьНеобходимоПропуститьСтрокуПриВыводеДанных(/*Выборка, Знач ПоПодстрокеСодержание, Знач ПоПодстрокеСубконто,
	Знач БезУчетаРегистра, Знач Подстрока, Знач МаксКоличествоСубконто*/)
		{
			if(true/*НЕ (ПоПодстрокеСодержание ИЛИ ПоПодстрокеСубконто)*/)
			{
			}
			//ПодстрокаПоиска = ?(БезУчетаРегистра, НРег(Подстрока), Подстрока);
			/*// поиск по ИЛИ на вхождение в содержание или в Субконто
*/
			if(true/*ПоПодстрокеСодержание*/)
			{
				if(true/*БезУчетаРегистра*/)
				{
					//СтрокаНайдена = Найти(НРег(Выборка.Содержание), ПодстрокаПоиска) > 0;
				}
				if(true/*СтрокаНайдена*/)
				{
					/*// строка уже найдена, дальше искать не надо
*/
				}
			}
			if(true/*ПоПодстрокеСубконто*/)
			{
			}
			/*// ничего не нашли
*/
			return null;
		}
		// процедура добовляет очередную строку к отборам отчета па проводкам

		public void ДополнитьОтборОчереднойСтрокой(/*ОтборДанных, ТаблицаОтборов, Знач СтрокаДБКТ, Знач Счет*/)
		{
		}
		// Создание структуры таблицы для хранения данных об отборе по субконто каждой корреспонденции

		public object СоздатьТаблицуДляХраненияОтбора(/*Знач ДобавлятьКолонкуИспользования = Ложь*/)
		{
			//ТаблицаОтбора = Новый ТаблицаЗначений();
			//ТаблицаОтбора.Колонки.Добавить("Имя", Новый ОписаниеТипов("Строка"));
			//ТаблицаОтбора.Колонки.Добавить("ПутьКДанным", Новый ОписаниеТипов("Строка"));
			//ТаблицаОтбора.Колонки.Добавить("Представление", Новый ОписаниеТипов("Строка"));
			//ТаблицаОтбора.Колонки.Добавить("ВидСравнения", Новый ОписаниеТипов("ВидСравнения"));
			//ТаблицаОтбора.Колонки.Добавить("Значение");
			//ТаблицаОтбора.Колонки.Добавить("ЗначениеС");
			//ТаблицаОтбора.Колонки.Добавить("ЗначениеПо");
			if(true/*ДобавлятьКолонкуИспользования*/)
			{
				//ТаблицаОтбора.Колонки.Добавить("Использование");
			}
			return null;
		}
		//процедура добавляет в таблицу очередной отбор

		public object ДобавитьВТаблицуОчереднойОтбор(/*ТаблицаОтбора, Знач Имя, Знач Значение, Знач ВидСравненияПоУмолчанию = Неопределено*/)
		{
			//СтрокаДобавления = ТаблицаОтбора.Добавить();
			//СтрокаДобавления.Имя = Имя;
			if(true/*ТипЗнч(Значение) = Тип("Структура")*/)
			{
				//СтрокаДобавления.Значение = Значение.Значение;
			}
			if(true/*ВидСравненияПоУмолчанию = Неопределено*/)
			{
				if(true/*ТипЗнч(Значение) = Тип("Структура")*/)
				{
					//СтрокаДобавления.ВидСравнения = Значение.ВидСравнения;
				}
			}
			return null;
		}

		public object ПолучитьТипСравненияПоЗначению(/*Значение*/)
		{
			if(true/*(ТипЗнч(Значение) = Тип("СписокЗначений") ИЛИ ТипЗнч(Значение) = Тип("Массив"))*/)
			{
			}
			return null;
		}
		// Получение строкового представления строки отборов
		//
		// Параметры
		//  ТаблицаОтборов  – ТаблицаЗначений, Отбор – Таблица отборов
		//
		// Возвращаемое значение:
		//   Строка   – строковое представление списка отборов
		//

		public object ПолучитьПредставлениеОтбораПоТаблице(/*ТаблицаОтборов*/)
		{
			//СтрокаОтборов = "";
			if(true/*ТипЗнч(ТаблицаОтборов) <> Тип("Отбор")*/)
			{
			}
			return null;
		}
		//Процедура заменяет в структуре отборы на отборы ДТ и КТ

		public void ЗаменитьОбщиеОтборыНаОтборыДтКт(/*ОтборДляРасшифровки, РасшифровкаОтборПоСчетам, Знач ВидОборота*/)
		{
			if(true/*ОтборДляРасшифровки = Неопределено*/)
			{
			}
			if(true/*ТипЗнч(ОтборДляРасшифровки) = Тип("ТаблицаЗначений")*/)
			{
			}
		}
		//Процедура заполняет настройки ограничений по параметрам

		public void НастроитьОтборыДанныхПопараметрам(/*Параметры, Корреспонденции, Валюта, ОтборПоВалюте*/)
		{
			//СтрокиОтбора = Параметры["Отбор"];
			//ОтборСубконто = СоздатьТаблицуДляХраненияОтбора();
			//ОтборКорСубконто = СоздатьТаблицуДляХраненияОтбора();
			//ОтборСубконтоДт = СоздатьТаблицуДляХраненияОтбора();
			//ОтборСубконтоКт = СоздатьТаблицуДляХраненияОтбора();
			//КорСчет = Неопределено;
			if(true/*ТипЗнч(СтрокиОтбора) = Тип("Соответствие")
		ИЛИ ТипЗнч(СтрокиОтбора) = Тип("Структура")*/)
			{
			}
			//СчетДт =  Параметры["СчетДт"];
			//СчетКт =  Параметры["СчетКт"];
			//Счет    = Параметры["Счет"];
			if(true/*КорСчет = Неопределено*/)
			{
				//КорСчет = Параметры["КорСчет"];
			}
			if(true/*ЗначениеЗаполнено(СчетДт) или ЗначениеЗаполнено(СчетКт)*/)
			{
				//стр = Корреспонденции.Добавить();
				//стр.Субконто = СоздатьТаблицуДляХраненияОтбора();
				/*// заполним фильтры по дебетовой аналитике
*/
				if(true/*ЗначениеЗаполнено(СчетДт)*/)
				{
					//стр.СчетДт = СчетДт;
					//ДополнитьОтборОчереднойСтрокой(ОтборСубконтоДт, стр.Субконто, "Дт", СчетДт);
				}
				/*// заполним фильтры по кредитовой аналитике
*/
				if(true/*ЗначениеЗаполнено(СчетКт)*/)
				{
					//стр.СчетКт = СчетКт;
					//ДополнитьОтборОчереднойСтрокой(ОтборСубконтоКт, стр.Субконто, "Кт", СчетКт);
				}
				/*//
*/
				if(true/*ОтборСубконто.Количество()>0*/)
				{
					if(true/*СчетКт<>КорСчет*/)
					{
						//ДополнитьОтборОчереднойСтрокой(ОтборСубконто, стр.Субконто, "Кт", СчетКт);
					}
				}
				if(true/*ОтборКорСубконто.Количество()>0*/)
				{
					if(true/*СчетКт<>КорСчет*/)
					{
						//ДополнитьОтборОчереднойСтрокой(ОтборКорСубконто, стр.Субконто, "Кт", СчетКт);
					}
				}
				//стр.ПредставлениеСубконто = ПолучитьПредставлениеОтбораПоТаблице(стр.Субконто);
			}
			//ВидУчета = Параметры["ВидУчета"];
			if(true/*ЗначениеЗаполнено(Видучета)*/)
			{
				//ОтборВидаУчетаДтКт = СоздатьТаблицуДляХраненияОтбора();
				//ОтборВидаУчетастр = ОтборВидаУчетаДтКт.Добавить();
				//ОтборВидаУчетастр.Имя = "";
				//ОтборВидаУчетастр.ПутьКДанным = "ВидУчетаДт";
				//ОтборВидаУчетастр.Представление = "Дт Вид учета";
				//ОтборВидаУчетастр.ВидСравнения = ВидСравнения.Равно;
				//ОтборВидаУчетастр.Значение = ВидУчета;
				//ОтборВидаУчетастр = ОтборВидаУчетаДтКт.Добавить();
				//ОтборВидаУчетастр.Имя = "";
				//ОтборВидаУчетастр.ПутьКДанным = "ВидУчетаКт";
				//ОтборВидаУчетастр.Представление = "Кт Вид учета";
				//ОтборВидаУчетастр.ВидСравнения = ВидСравнения.Равно;
				//ОтборВидаУчетастр.Значение = ВидУчета;
			}
		}
		///////////////////////////////////////////////////////////////////////////////
		//ОБОРОТЫ МЕЖДУ СУБКОНТО
		///////////////////////////////////////////////////////////////////////////////
		///////////////////////////////////////////////////////////////////////////////
		//КАРТОЧКА СУБКОНТО
		///////////////////////////////////////////////////////////////////////////////
		//Функция возвращает строку ограничений по типу субконто

		public object СформироватьОграниченияПоТипуСубконто(/*Запрос, Знач МассивСубконто, Знач ИмяРегистраБухгалтерии, Знач ИмяТаблицыСвязки*/)
		{
			//ТекущееОграничений = "";
			//НомерОграничения = 1;
			return null;
		}
		//Процедура удаляет строки с пустым субконто из таблицы

		public void УдалитьПустыеСубконтоИзТабличнойЧасти(/*ТабЧастьСубконто*/)
		{
			//СчСубконто = ТабЧастьСубконто.Количество() - 1;
			while(true/*СчСубконто >= 0*/)
			{
				if(true/*НЕ ЗначениеЗаполнено(ТабЧастьСубконто[СчСубконто].ВидСубконто)*/)
				{
					//ТабЧастьСубконто.Удалить(СчСубконто);
				}
				//СчСубконто = СчСубконто - 1;
			}
			//;;
		}
		//Процедура изменяет типы у отборов построителя по субконто

		public void УстановитьТипыОтборовПостроителяПоСубконто(/*ПостроительОтчета, МассивСубконто*/)
		{
			//Сч = 0;
		}
	}
}
